Umko 0.7

[F. Bluemers]

Have a look at pos_eval.ccp(umko 0.7)

Code: Select all

void Position::eval_mat(MaterialHash* mh) const{
    int recog;
    int flags, cflags[2], mul[2];

    const int wp = num[WP];
    const int wn = num[WN];
    const int wb = num[WB];
    const int wr = num[WR];
    const int wq = num[WQ];

    const int bp = num[BP];
    const int bn = num[BN];
    const int bb = num[BB];
    const int br = num[BR];
    const int bq = num[BQ];

    const int wt = num[W]-1;
    const int bt = num[B]-1;

    const int wm = wb + wn;
    const int bm = bb + bn;

    recog = EG_NONE;
    if(wt == 0 && bt == 0) { recog = EG_KK; }
    else if (wt == 1 && bt == 0) {
        if (wb == 1) recog = EG_KBK;
        if (wn == 1) recog = EG_KNK;
        if (wp == 1) recog = EG_KPK;
    } else if (wt == 0 && bt == 1) {
        if (bb == 1) recog = EG_KKB;
        if (bn == 1) recog = EG_KKN;
        if (bp == 1) recog = EG_KKP;
    } else if (wt == 1 && bt == 1) {
        if (wq == 1 && bq == 1) recog = EG_KQKQ;
        if (wq == 1 && bp == 1) recog = EG_KQKP;
        if (wp == 1 && bq == 1) recog = EG_KPKQ;

        if (wr == 1 && br == 1) recog = EG_KRKR;
        if (wr == 1 && bp == 1) recog = EG_KRKP;
        if (wp == 1 && br == 1) recog = EG_KPKR;

        if (wb == 1 && bb == 1) recog = EG_KBKB;
        if (wb == 1 && bp == 1) recog = EG_KBKP;
        if (wp == 1 && bb == 1) recog = EG_KPKB;

        if (wn == 1 && bn == 1) recog = EG_KNKN;
        if (wn == 1 && bp == 1) recog = EG_KNKP;
        if (wp == 1 && bn == 1) recog = EG_KPKN;
    } else if (wt == 2 && bt == 0) {
        if (wb == 1 && wp == 1) recog = EG_KBPK;
        if (wn == 1 && wp == 1) recog = EG_KNPK;
    } else if (wt == 0 && bt == 2) {
        if (bb == 1 && bp == 1) recog = EG_KKBP;
        if (bn == 1 && bp == 1) recog = EG_KKNP;
    } else if (wt == 2 && bt == 1) {
        if (wr == 1 && wp == 1 && br == 1) recog = EG_KRPKR;
        if (wb == 1 && wp == 1 && bb == 1) recog = EG_KBPKB;
    } else if (wt == 1 && bt == 2) {
        if (wr == 1 && br == 1 && bp == 1) recog = EG_KRKRP;
        if (wb == 1 && bb == 1 && bp == 1) recog = EG_KBKBP;
    }

snip------------------------------


fruit 2.1 material.ccp

Code: Select all

static void material_comp_info(material_info_t * info, const board_t * board) {

   int wp, wn, wb, wr, wq;
   int bp, bn, bb, br, bq;
   int wt, bt;
   int wm, bm;
   int colour;
   int recog;
   int flags;
   int cflags[ColourNb];
   int mul[ColourNb];
   int phase;
   int opening, endgame;

   ASSERT(info!=NULL);
   ASSERT(board!=NULL);

   // init

   wp = board->number[WhitePawn12];
   wn = board->number[WhiteKnight12];
   wb = board->number[WhiteBishop12];
   wr = board->number[WhiteRook12];
   wq = board->number[WhiteQueen12];

   bp = board->number[BlackPawn12];
   bn = board->number[BlackKnight12];
   bb = board->number[BlackBishop12];
   br = board->number[BlackRook12];
   bq = board->number[BlackQueen12];

   wt = wq + wr + wb + wn + wp; // no king
   bt = bq + br + bb + bn + bp; // no king

   wm = wb + wn;
   bm = bb + bn;

   // recogniser

   recog = MAT_NONE;

   if (false) {

   } else if (wt == 0 && bt == 0) {

      recog = MAT_KK;

   } else if (wt == 1 && bt == 0) {

      if (wb == 1) recog = MAT_KBK;
      if (wn == 1) recog = MAT_KNK;
      if (wp == 1) recog = MAT_KPK;

   } else if (wt == 0 && bt == 1) {

      if (bb == 1) recog = MAT_KKB;
      if (bn == 1) recog = MAT_KKN;
      if (bp == 1) recog = MAT_KKP;

   } else if (wt == 1 && bt == 1) {

      if (wq == 1 && bq == 1) recog = MAT_KQKQ;
      if (wq == 1 && bp == 1) recog = MAT_KQKP;
      if (wp == 1 && bq == 1) recog = MAT_KPKQ;

      if (wr == 1 && br == 1) recog = MAT_KRKR;
      if (wr == 1 && bp == 1) recog = MAT_KRKP;
      if (wp == 1 && br == 1) recog = MAT_KPKR;

      if (wb == 1 && bb == 1) recog = MAT_KBKB;
      if (wb == 1 && bp == 1) recog = MAT_KBKP;
      if (wp == 1 && bb == 1) recog = MAT_KPKB;

      if (wn == 1 && bn == 1) recog = MAT_KNKN;
      if (wn == 1 && bp == 1) recog = MAT_KNKP;
      if (wp == 1 && bn == 1) recog = MAT_KPKN;

   } else if (wt == 2 && bt == 0) {

      if (wb == 1 && wp == 1) recog = MAT_KBPK;
      if (wn == 1 && wp == 1) recog = MAT_KNPK;

   } else if (wt == 0 && bt == 2) {

      if (bb == 1 && bp == 1) recog = MAT_KKBP;
      if (bn == 1 && bp == 1) recog = MAT_KKNP;

   } else if (wt == 2 && bt == 1) {

      if (wr == 1 && wp == 1 && br == 1) recog = MAT_KRPKR;
      if (wb == 1 && wp == 1 && bb == 1) recog = MAT_KBPKB;

   } else if (wt == 1 && bt == 2) {

      if (wr == 1 && br == 1 && bp == 1) recog = MAT_KRKRP;
      if (wb == 1 && bb == 1 && bp == 1) recog = MAT_KBKBP;
   }



2 more samples,same files:

Code: Select all

    if (wt == wb+wp && wp >= 1) cflags[White] |= MatRookPawnFlag;
    if (wt == wb+wp && wb <= 1 && wp >= 1 && bt > bp) cflags[White] |= MatBishopFlag;
    if (wt == 2 && wn == 1 && wp == 1 && bt > bp) cflags[White] |= MatKnightFlag;

    if (bt == bb+bp && bp >= 1) cflags[Black] |= MatRookPawnFlag;
    if (bt == bb+bp && bb <= 1 && bp >= 1 && wt > wp) cflags[Black] |= MatBishopFlag;
    if (bt == 2 && bn == 1 && bp == 1 && wt > wp) cflags[Black] |= MatKnightFlag;

    if (recog == EG_KQKQ || recog == EG_KRKR) {
        mul[White] = 0;
        mul[Black] = 0;
    }

    if (bq >= 1 && bq+br+bb+bn >= 2) cflags[White] |= MatKingFlag;
    if (wq >= 1 && wq+wr+wb+wn >= 2) cflags[Black] |= MatKingFlag;

    int phase = TotalPhase;

    phase -= wp * PiecePhase[PAWN];
    phase -= wn * PiecePhase[KNIGHT];
    phase -= wb * PiecePhase[BISHOP];
    phase -= wr * PiecePhase[ROOK];
    phase -= wq * PiecePhase[QUEEN];

    phase -= bp * PiecePhase[PAWN];
    phase -= bn * PiecePhase[KNIGHT];
    phase -= bb * PiecePhase[BISHOP];
    phase -= br * PiecePhase[ROOK];
    phase -= bq * PiecePhase[QUEEN];

    if(phase < 0) phase = 0;

    phase = (phase * 256 + (TotalPhase / 2)) / TotalPhase;

    int opening = 0, endgame = 0;

    const int owf = wn*MAT[KNIGHT][Opening] + wb*MAT[BISHOP][Opening] + wr*MAT[ROOK][Opening] + wq*MAT[QUEEN][Opening];
    opening += wp * MAT[PAWN][Opening];
    opening += owf;

    const int obf = bn*MAT[KNIGHT][Opening] + bb*MAT[BISHOP][Opening] + br*MAT[ROOK][Opening] + bq*MAT[QUEEN][Opening];
    opening -= bp * MAT[PAWN][Opening];
    opening -= obf;

    const int ewf = wn*MAT[KNIGHT][Endgame] + wb*MAT[BISHOP][Endgame] + wr*MAT[ROOK][Endgame] + wq*MAT[QUEEN][Endgame];
    endgame += wp * MAT[PAWN][Endgame];
    endgame += ewf;

    const int ebf = bn*MAT[KNIGHT][Endgame] + bb*MAT[BISHOP][Endgame] + br*MAT[ROOK][Endgame] + bq*MAT[QUEEN][Endgame];
    endgame -= bp * MAT[PAWN][Endgame];
    endgame -= ebf;


fruit 2.1:

Code: Select all

   // potential draw for white

   if (wt == wb+wp && wp >= 1) cflags[White] |= MatRookPawnFlag;
   if (wt == wb+wp && wb <= 1 && wp >= 1 && bt > bp) cflags[White] |= MatBishopFlag;

   if (wt == 2 && wn == 1 && wp == 1 && bt > bp) cflags[White] |= MatKnightFlag;

   // potential draw for black

   if (bt == bb+bp && bp >= 1) cflags[Black] |= MatRookPawnFlag;
   if (bt == bb+bp && bb <= 1 && bp >= 1 && wt > wp) cflags[Black] |= MatBishopFlag;

   if (bt == 2 && bn == 1 && bp == 1 && wt > wp) cflags[Black] |= MatKnightFlag;

   // draw leaf (likely draw)

   if (recog == MAT_KQKQ || recog == MAT_KRKR) {
      mul[White] = 0;
      mul[Black] = 0;
   }

   // king safety

   if (bq >= 1 && bq+br+bb+bn >= 2) cflags[White] |= MatKingFlag;
   if (wq >= 1 && wq+wr+wb+wn >= 2) cflags[Black] |= MatKingFlag;

   // phase (0: opening -> 256: endgame)

   phase = TotalPhase;

   phase -= wp * PawnPhase;
   phase -= wn * KnightPhase;
   phase -= wb * BishopPhase;
   phase -= wr * RookPhase;
   phase -= wq * QueenPhase;

   phase -= bp * PawnPhase;
   phase -= bn * KnightPhase;
   phase -= bb * BishopPhase;
   phase -= br * RookPhase;
   phase -= bq * QueenPhase;

   if (phase < 0) phase = 0;

   ASSERT(phase>=0&&phase<=TotalPhase);
   phase = (phase * 256 + (TotalPhase / 2)) / TotalPhase;

   ASSERT(phase>=0&&phase<=256);

   // material

   opening = 0;
   endgame = 0;

   opening += wp * PawnOpening;
   opening += wn * KnightOpening;
   opening += wb * BishopOpening;
   opening += wr * RookOpening;
   opening += wq * QueenOpening;

   opening -= bp * PawnOpening;
   opening -= bn * KnightOpening;
   opening -= bb * BishopOpening;
   opening -= br * RookOpening;
   opening -= bq * QueenOpening;

   endgame += wp * PawnEndgame;
   endgame += wn * KnightEndgame;
   endgame += wb * BishopEndgame;
   endgame += wr * RookEndgame;
   endgame += wq * QueenEndgame;

   endgame -= bp * PawnEndgame;
   endgame -= bn * KnightEndgame;
   endgame -= bb * BishopEndgame;
   endgame -= br * RookEndgame;
   endgame -= bq * QueenEndgame;



the owf obf,ebf ,ewf calculations were introduced in toga iirc.
not that it matters.

[F. Bluemers]

A bit more:
pos_eval.ccp from umko:

Code: Select all

void Position::eval_patterns(EvalInfo& info) const{

    if((piece[A7] == WB && piece[B6] == BP) || (piece[B8] == WB && piece[C7] == BP)){
        info.eval[Opening] -= TrappedBishop;
        info.eval[Endgame] -= TrappedBishop;
    }
    if((piece[H7] == WB && piece[G6] == BP) || (piece[G8] == WB && piece[F7] == BP)){
        info.eval[Opening] -= TrappedBishop;
        info.eval[Endgame] -= TrappedBishop;
    }
    if((piece[A2] == BB && piece[B3] == WP) || (piece[B1] == BB && piece[C2] == WP)){
        info.eval[Opening] += TrappedBishop;
        info.eval[Endgame] += TrappedBishop;
    }
    if((piece[H2] == BB && piece[G3] == WP) || (piece[G1] == BB && piece[F2] == WP)){
        info.eval[Opening] += TrappedBishop;
        info.eval[Endgame] += TrappedBishop;
    }

    if(piece[A6] == WB && piece[B5] == BP) {
        info.eval[Opening] -= TrappedBishop / 2;
        info.eval[Endgame] -= TrappedBishop / 2;
    }
    if(piece[H6] == WB && piece[G5] == BP) {
        info.eval[Opening] -= TrappedBishop / 2;
        info.eval[Endgame] -= TrappedBishop / 2;
    }
    if(piece[A3] == BB && piece[B4] == WP) {
        info.eval[Opening] += TrappedBishop / 2;
        info.eval[Endgame] += TrappedBishop / 2;
    }
    if(piece[H3] == BB && piece[G4] == WP) {
        info.eval[Opening] += TrappedBishop / 2;
        info.eval[Endgame] += TrappedBishop / 2;
    }

    if(piece[D2] == WP && piece[D3] != NO_PIECE && piece[C1] == WB)
        info.eval[Opening] -= BlockedBishop;
    if(piece[E2] == WP && piece[E3] != NO_PIECE && piece[F1] == WB)
        info.eval[Opening] -= BlockedBishop;
    if(piece[D7] == BP && piece[D6] != NO_PIECE && piece[C8] == BB)
        info.eval[Opening] += BlockedBishop;
    if(piece[E7] == BP && piece[E6] != NO_PIECE && piece[F8] == BB)
        info.eval[Opening] += BlockedBishop;

    if((piece[C1]==WK || piece[B1]==WK) && (piece[A1]==WR || piece[A2]==WR || piece[B1]==WR))
        info.eval[Opening] -= BlockedRook;
    if((piece[F1]==WK || piece[G1]==WK) && (piece[H1]==WR || piece[H2]==WR || piece[G1]==WR))
        info.eval[Opening] -= BlockedRook;
    if((piece[C8]==BK || piece[B8]==BK) && (piece[A8]==BR || piece[A7]==BR || piece[B8]==BR))
        info.eval[Opening] += BlockedRook;
    if((piece[F8]==BK || piece[G8]==BK) && (piece[H8]==BR || piece[H7]==BR || piece[G8]==BR))
        info.eval[Opening] += BlockedRook;


eval.ccp from fruit 2.1

Code: Select all

static void eval_pattern(const board_t * board, int * opening, int * endgame) {

   ASSERT(board!=NULL);
   ASSERT(opening!=NULL);
   ASSERT(endgame!=NULL);

   // trapped bishop (7th rank)

   if ((board->square[A7] == WB && board->square[B6] == BP)
    || (board->square[B8] == WB && board->square[C7] == BP)) {
      *opening -= TrappedBishop;
      *endgame -= TrappedBishop;
   }

   if ((board->square[H7] == WB && board->square[G6] == BP)
    || (board->square[G8] == WB && board->square[F7] == BP)) {
      *opening -= TrappedBishop;
      *endgame -= TrappedBishop;
   }

   if ((board->square[A2] == BB && board->square[B3] == WP)
    || (board->square[B1] == BB && board->square[C2] == WP)) {
      *opening += TrappedBishop;
      *endgame += TrappedBishop;
   }

   if ((board->square[H2] == BB && board->square[G3] == WP)
    || (board->square[G1] == BB && board->square[F2] == WP)) {
      *opening += TrappedBishop;
      *endgame += TrappedBishop;
   }

   // trapped bishop (6th rank)

   if (board->square[A6] == WB && board->square[B5] == BP) {
      *opening -= TrappedBishop / 2;
      *endgame -= TrappedBishop / 2;
   }

   if (board->square[H6] == WB && board->square[G5] == BP) {
      *opening -= TrappedBishop / 2;
      *endgame -= TrappedBishop / 2;
   }

   if (board->square[A3] == BB && board->square[B4] == WP) {
      *opening += TrappedBishop / 2;
      *endgame += TrappedBishop / 2;
   }

   if (board->square[H3] == BB && board->square[G4] == WP) {
      *opening += TrappedBishop / 2;
      *endgame += TrappedBishop / 2;
   }

   // blocked bishop

   if (board->square[D2] == WP && board->square[D3] != Empty && board->square[C1] == WB) {
      *opening -= BlockedBishop;
   }

   if (board->square[E2] == WP && board->square[E3] != Empty && board->square[F1] == WB) {
      *opening -= BlockedBishop;
   }

   if (board->square[D7] == BP && board->square[D6] != Empty && board->square[C8] == BB) {
      *opening += BlockedBishop;
   }

   if (board->square[E7] == BP && board->square[E6] != Empty && board->square[F8] == BB) {
      *opening += BlockedBishop;
   }

   // blocked rook

   if ((board->square[C1] == WK || board->square[B1] == WK)
    && (board->square[A1] == WR || board->square[A2] == WR || board->square[B1] == WR)) {
      *opening -= BlockedRook;
   }

   if ((board->square[F1] == WK || board->square[G1] == WK)
    && (board->square[H1] == WR || board->square[H2] == WR || board->square[G1] == WR)) {
      *opening -= BlockedRook;
   }

   if ((board->square[C8] == BK || board->square[B8] == BK)
    && (board->square[A8] == BR || board->square[A7] == BR || board->square[B8] == BR)) {
      *opening += BlockedRook;
   }

   if ((board->square[F8] == BK || board->square[G8] == BK)
    && (board->square[H8] == BR || board->square[H7] == BR || board->square[G8] == BR)) {
      *opening += BlockedRook;
   }
}


[F. Bluemers]

I could go on forever ...
pos_eval.ccp(umko 0.7)

Code: Select all

void Position::eval_passer(EvalInfo& info, const PawnHash* ph) const {
    Bitboard bb,b;
    Square sq;
    Rank r;
    int opening[2] = {0,0}, endgame[2] = {0,0}, delta, min, max;
    Color opp;

    Square kSq = first_bit(bitboard[WK]);
    Square opp_kSq = first_bit(bitboard[BK]);

    for(Color c = White; c <= Black; c++){
        bb = ph->passed[c];
        opp = c^1;

        if(c == Black){
            delta = kSq;
            kSq = opp_kSq;
            opp_kSq = Square(delta);
        }

        while(bb){
            sq = first_bit_clear(bb);

            if(c == White) r = rank(sq);
            else r = Rank(RANK_8 - rank(sq));

            b = BB_1<<sq;

            opening[c] += quad(PassedMin[Opening],PassedMax[Opening], r);

            min = PassedMin[Endgame];
            max = PassedMax[Endgame];
            delta = max - min;

            if(((bitboard[KNIGHT + opp] | bitboard[BISHOP + opp] | bitboard[ROOK + opp] | bitboard[QUEEN + opp]) == 0) &&
               (unstoppable_passer(sq,c) || king_passer(sq,c))){
                delta += UnstoppablePasser;
            }
            else if(free_passer(sq,c)){
                delta += FreePasser;
            }

            delta -= pawn_att_dist(sq,kSq,c) * AttackerDistance;
            delta += pawn_def_dist(sq,opp_kSq,c) * DefenderDistance;

            endgame[c] += min;
            if (delta > 0) endgame[c] += quad(0,delta,r);
        }
    }

    info.eval[Opening] += opening[White] - opening[Black];
    info.eval[Endgame] += endgame[White] - endgame[Black];
}

inline int Position::quad(const int min, const int max, const int x) {
   return  min + ((max - min) * Bonus[x] + 128) / 256;
}


Notice the quad function,typical to fruit.
eval.ccp (fruit 2.1)

Code: Select all

static void eval_passer(const board_t * board, const pawn_info_t * pawn_info, int * opening, int * endgame) {

   int colour;
   int op[ColourNb], eg[ColourNb];
   int att, def;
   int bits;
   int file, rank;
   int sq;
   int min, max;
   int delta;

   ASSERT(board!=NULL);
   ASSERT(pawn_info!=NULL);
   ASSERT(opening!=NULL);
   ASSERT(endgame!=NULL);

   // init

   for (colour = 0; colour < ColourNb; colour++) {
      op[colour] = 0;
      eg[colour] = 0;
   }

   // passed pawns

   for (colour = 0; colour < ColourNb; colour++) {

      att = colour;
      def = COLOUR_OPP(att);

      for (bits = pawn_info->passed_bits[att]; bits != 0; bits &= bits-1) {

         file = BIT_FIRST(bits);
         ASSERT(file>=FileA&&file<=FileH);

         rank = BIT_LAST(board->pawn_file[att][file]);
         ASSERT(rank>=Rank2&&rank<=Rank7);

         sq = SQUARE_MAKE(file,rank);
         if (COLOUR_IS_BLACK(att)) sq = SQUARE_RANK_MIRROR(sq);

         ASSERT(PIECE_IS_PAWN(board->square[sq]));
         ASSERT(COLOUR_IS(board->square[sq],att));

         // opening scoring

         op[att] += quad(PassedOpeningMin,PassedOpeningMax,rank);

         // endgame scoring init

         min = PassedEndgameMin;
         max = PassedEndgameMax;

         delta = max - min;
         ASSERT(delta>0);

         // "dangerous" bonus

         if (board->piece_size[def] <= 1 // defender has no piece
          && (unstoppable_passer(board,sq,att) || king_passer(board,sq,att))) {
            delta += UnstoppablePasser;
         } else if (free_passer(board,sq,att)) {
            delta += FreePasser;
         }

         // king-distance bonus

         delta -= pawn_att_dist(sq,KING_POS(board,att),att) * AttackerDistance;
         delta += pawn_def_dist(sq,KING_POS(board,def),att) * DefenderDistance;

         // endgame scoring

         eg[att] += min;
         if (delta > 0) eg[att] += quad(0,delta,rank);
      }
   }

   // update

   *opening += ((op[White] - op[Black]) * PassedPawnWeight) / 256;
   *endgame += ((eg[White] - eg[Black]) * PassedPawnWeight) / 256;
}



etc. etc
Best
Fonzy

[Volker Pittlik]

Thanks for the information.
But in Umko timecontrol is broken! That provides proof it is not what you might think .

vp

[Carlos Pagador]

Hi,

I am not a chess programmer, so I ask you experts, is this enough evidence to affirm that Umko is a Fruit derivative?
Its progress in the last months is "amazing."

Regards,
Carlos

[Matthias Gemuh]

Hi,

I am not a chess programmer, so I ask you experts, is this enough evidence to affirm that Umko is a Fruit derivative?
Its progress in the last months is "amazing."

Regards,
Carlos

DanChess was considered a Crafty clone and disqualified from the chess community because it cloned major parts of Crafty's evaluation function. Umko has done the same with Fruit's evaluation function.
Having a different time management is no justication for cloning.

Matthias.

[Volker Pittlik]

...Having a different time management is no justication for cloning...

Herr, Hirn. http://en.wikipedia.org/wiki/Irony

[Volker Pittlik]

.. is this enough evidence to affirm that Umko is a Fruit derivative?...

From my point of view there are to much and to strong similarities to be here by random. It's O.K. to reuse or even copy code from a GPLed program (what is the case here), but doing so without necessary announcement is an infringement of the GPL. Together with other things this is enough for me to stop testing this program.

There will always be a stronger program as I have on my computer. However, for me even the moderate ones from the past on 10 year old hardware are way to strong. I'd like to have fun with this hobby. If I always want to have to the strongest possible by all means I'd miss the fun.

vp

P.S. typos corrected

[Kirill Kryukov]

Umko is removed from my testing queue. Thanks.

[Graham Banks]

If it's a clearcut case (as it seems to be), I won't test it either.
I'm no expert in these matters.

[Olivier Deville]

Hi all

I have invited the author to register to the forum and answer if he feels like it.

Olivier

[borko]

As you can see from the code some parts of it is based on Toga/Fruit but it is our implementation. Umko also contains some concepts that are not implemented in Toga/Fruit, for example bitboards. Umko is still in development, unstable and not yet documented. Therefore we have to apologize because we have not yet written that some parts of the code are based on Toga/Fruit.

Borko

[Werner Schüle]

Have a look at pos_eval.ccp(umko 0.7)

[snip------------------------------
[/code]
fruit 2.1 material.ccp
the owf obf,ebf ,ewf calculations were introduced in toga iirc.
not that it matters.

Thanks a lot Fonzy for finding that out!

Werner

[Olivier Deville]

Umko 0.8 now seems to include the proper license.

It won't play in ChessWar though, since I do not accept derivatives.

Olivier

[Olivier Deville]

Umko 0.8 now seems to include the proper license.

It won't play in ChessWar though, since I do not accept derivatives.

Olivier

I see Umko 1.0 is out now : http://sourceforge.net/projects/umko/files/

Do you think it should be allowed to play in ChessWar now ? Is Umko still a derivative in your opinion ?

Olivier

[Dann Corbit]

Hi,

I am not a chess programmer, so I ask you experts, is this enough evidence to affirm that Umko is a Fruit derivative?
Its progress in the last months is "amazing."

Regards,
Carlos

DanChess was considered a Crafty clone and disqualified from the chess community because it cloned major parts of Crafty's evaluation function. Umko has done the same with Fruit's evaluation function.
Having a different time management is no justication for cloning.

Matthias.

DanChess borrowed the SEE function from Crafty, not the eval.