🚀 go-pugleaf

Well I think I dug through the old pre 4pl67 code, to find
the correct versions of dist_, kpkwv_, ScoreLoneKing etc
for the next gnuchess.
Note K1PK for 4pl63/64 had a problem, that is fixed
in this version, I think.  Here are the 2 options,
the new 4PL68 code appears first followed by the
correct (4pl64 with a bit of help) code.

-Roger
uzun@crash.cts.com
=============================================


#ifndef PRE4PL67 // this is the new 4pl68 code
// I am told it is WORSE than the #else clause which
// is based on old 4pl64 code

  short dist_ (short, short, short, short);
  short kpkwv_ (short, short, short, short, short, short);

short 
kpkwv_ (short pf, short pr, short wf, short wr, short bf, short br)
{

  /*
   *  Don Beal's routine, which was originally in Fortran.  See AICC 2
   */

  static short wbdd, mbpf, nbpf, blpu;
  short dist_ (short, short, short, short);
  static short brpu, mwpf, wlpu, wrpu, blpuu, brpuu, wlpuu, wrpuu, md,
    bq, blpuuu, brpuuu, bsd, tbf, sgf, bpp, sdr, sgr, wsd, wsg, ppr, wpp;

  ppr = ((pr == 2)?3:0);
  if (pf == 1)
  { if (bf == 3)
    { if (pr == 7 && wf == 1 && wr == 8 && br > 6) return(0);
      if (pr == 6 && wf < 4 && wr == 6 && br == 8) return(1);
    }

    if (bf == 1 && br > pr) return(0);
    if (pr == 7 && bf > 2) return(1);
    if (bf <= 3 && br - ppr > 1) return(0);
    if (wf == 1 && bf == 3 && wr - pr == 1 && br - pr == 1) return(0);
  }
  bq = dist_ (bf, br, pf, 8);
  if (bq > 8 - ppr) return(1);
  mbpf = bf - pf;
  if (mbpf < 0) mbpf = -mbpf;
  bpp = dist_ (bf, br, pf, ppr);
  wpp = dist_ (wf, wr, pf, ppr);
  if (bpp - wpp < -1 && br - pr != mbpf) return(0);
  if (pf == 1 && pr <= 3 && wf <= 2 && wr == 8 && bf == 4 && br >= 7) return(1);
  if (!(pf != 2 || pr != 6 || bf != 1 || br != 8))
  { if (wf <= 3 && wr == 6) return(0);
    if (wf == 4 && wr == 8) return(0);
  }
  if (pr == 7)
  { if (wr < 8 && wpp == 2 && bq == 0) return(1);
    if (wr == 6 && wf == pf && bq == 0) return(1);
    if (wr >= 6 && wpp <= 2 && bq != 0) return(1);
  }
  blpuu = dist_ (bf, br, pf - 1, pr + 2);
  wbdd = dist_ (wf, wr, bf, br - 2);
  brpuu = dist_ (bf, br, pf + 1, pr + 2);
  if (pr == 6)
  { if (dist_ (bf, br, pf + 1, pr) > 1 &&
        brpuu > dist_ (wf, wr, pf + 1, pr)) return(1);
    if (pf != 1)
    { if (blpuu > dist_ (wf, wr, pf - 1, pr)) return(1);
      if (br == 8 && mbpf == 1 && wbdd == 1) return(1);
      if (br > 6 && nbpf == 2 && dist_ (wf, wr, bf, 5) <= 1) return(1);
    }
    else
      if (wf == 1 && wr == 8 && bf == 2 && br == 6) return(0);
  }
  mwpf = wf - pf;
  if (mwpf < 0) mwpf = -mwpf;
  if (pr >= 5 && mwpf == 2 && wr == pr && bf == wf && br - pr == 2) return(1);
  brpu = dist_ (bf, br, pf + 1, pr + 1);
  wrpu = dist_ (wf, wr, pf + 1, pr + 1);
  blpu = dist_ (bf, br, pf - 1, pr + 1);
  wlpu = dist_ (wf, wr, pf - 1, pr + 1);
  if (!(pf == 1 || pr != 5))
  { if (mwpf <= 1 && wr - pr == 1) return(1);
    if (wrpu == 1 && brpu > 1) return(1);
    if (wr >= 4 && bf == wf && br - pr >= 2 && mbpf == 3) return(1);
    if (wlpu == 1 && blpu > 1) return(1);
  }
  if (pr == 2 && br == 3 && mbpf > 1 && dist_ (wf, wr, bf, br + 2) <= 1) return(1);
  if (wr - pr == 2 && br == pr && mbpf == 1 && mwpf > 1 &&
      (wf - pf) * (bf - pf) > 0) return(0);
  if (pf == 1 && wf == 1 && wr == br && bf > 3) return(1);
  sgf = pf - 1;
  if (wf >= pf) { sgf = pf + 1; }
  sgr = wr - (mwpf - 1);
  if (mwpf == 0 && wr > br) sgr = wr - 1;
  wsg = dist_ (wf, wr, sgf, sgr);
  if (wr - pr - mwpf > 0 && wr - br >= -1 && bpp - (wsg + (sgr - ppr))
      >= -1 && dist_ (bf, br, sgf, sgr) > wsg) return(1);
  md = mbpf - mwpf;
  if (!(pf != 1 || bf <= 3))
  { sdr = br + (bf - 3);
    if (sdr > 8) sdr = 8;
    if (wr > br + 1) sdr = br;
    if (sdr > ppr)
    { wsd = dist_ (wf, wr, 3, sdr);
      bsd = dist_ (bf, br, 3, sdr);
      if (bsd - wsd < -1) return(0);
      if (bsd <= wsd && md <= 0) return(0);
    }
  }
  brpuuu = dist_ (bf, br, pf + 1, pr + 3);
  if (brpu > wrpu && brpuuu > wrpu && pr - wr != pf - wf) return(1);
  if (brpuuu == 0 && wrpu == 1) return(1);
  blpuuu = dist_ (bf, br, pf - 1, pr + 3);
  if (pf != 1)
  { if (blpu > wlpu && blpuuu > wlpu && pr - wr != wf - pf) return(1);
    if (blpuuu == 0 && wlpu == 1) return(1);
  }
  wrpuu = dist_ (wf, wr, pf + 1, pr + 2);
  if (brpuu > wrpuu) return(1);
  wlpuu = dist_ (wf, wr, pf - 1, pr + 2);
  if (pf > 1 && blpuu > wlpuu) return(1);
  if (br == pr)
  { if (mwpf <= 2 && wr - pr == -1 && mbpf != 2) return(1);
    if (dist_ (wf, wr, bf - 1, br + 2) <= 1 && bf - pf > 1) return(1);
    if (dist_ (wf, wr, bf + 1, br + 2) <= 1 && bf - pf < -1) return(1);
  }
  if (pf != 1)
  { if (br == pr && mbpf > 1 && dist_ (wf, wr, pf, pr - 1) <= 1) return(1);
    if (br - pr >= 3 && wbdd == 1) return(1);
    if (wr - pr >= 2 && wr < br && md >= 0) return(1);
    if (mwpf <= 2 && wr - pr >= 3 && bf != pf && wr - br <= 1) return(1);
    if (wr >= pr && br - pr >= 5 && mbpf >= 3 && md >= -1 && ppr == 3) return(1);
    if (md >= -1 && pr == 2 && br == 8) return(1);
  }
  tbf = bf - 1;
  if (pf > bf) tbf = bf + 1;
  if (mbpf > 1 && br == ppr && dist_ (wf, wr, tbf, wr + 2) <= 1) return(1);
  if (br == pr && bf - pf == -2 && dist_ (wf, wr, pf + 2, pr - 1) <= 1) return(1);
  if (pf > 2 && br == pr && bf - pf == 2 &&
      dist_ (wf, wr, pf - 2, pr - 1) <= 1) return(1);
  return(0);
}				/* kpkwv_ */

short 
kpkbv_ (short pf, short pr, short wf, short wr, short bf, short br)
{
  static short incf[8] =
    {0, 1, 1, 1, 0, -1, -1, -1};
  static short incr[8] =
    {1, 1, 0, -1, -1, -1, 0, 1};

  short dist_ (short, short, short, short);
  short kpkwv_ (short, short, short, short, short, short);
  static short i, nm, nbf, nbr;

  nm = 0;
  for (i = 0; i < 8; ++i)
    {
      nbf = bf + incf[i];
      if (nbf < 1 || nbf > 8) continue;
      nbr = br + incr[i];
      if (nbr < 1 || nbr > 8) continue;
      if (dist_ (nbf, nbr, wf, wr) < 2) continue;
      if (nbf == pf && nbr == pr) return(0);
      if (nbr == pr + 1 && (nbf == pf - 1 || nbf == pf + 1)) continue;
      ++nm;
      if (kpkwv_ (pf, pr, wf, wr, nbf, nbr) == 0) return(0);
    }
  if (nm > 0) return(-1);
  return(0);
}				/* kpkbv_ */

short 
dist_ (short f1, short r1, short f2, short r2)
{
  short ts;
  static short fd, rd;

  fd = f2 - f1;
  if (fd < 0) fd = -fd;

  rd = r2 - r1;
  if (rd < 0) rd = -rd;

 ts = ((rd > fd) ? rd : fd);
 return(ts);
}				/* dist_ */

inline
int
ScoreK1PK (short side,
	   short winner,
	   short loser,
	   short king1,
	   register short king2,
	   register short sq)

     /*
      *  We call Don Beal's routine with the necessary parameters and determine
      *  win/draw/loss.  Then we compute the real evaluation which is +-500 for
      *  a win/loss and 10 for a draw, plus some points to lead the computer to
      *  a decisive winning/drawing line.
      */

{
  short win, sqc, sqr, k1c, k1r, k2c, k2r;
  const int drawn = 10, won = 500;

  sqc = column (sq) + 1;
  sqr = row (sq) + 1;
  k1c = column (king1) + 1;
  k1r = row (king1) + 1;
  k2c = column (king2) + 1;
  k2r = row (king2) + 1;
  if (winner == black)
    {
      sqr = 9 - sqr;
      k1r = 9 - k1r;
      k2r = 9 - k2r;
    }
  if (sqc > 4)
    {
      sqc = 9 - sqc;
      k1c = 9 - k1c;
      k2c = 9 - k2c;
    }

  if (side == winner)
    win = kpkwv_ (sqc, sqr, k1c, k1r, k2c, k2r);
  else
    win = kpkbv_ (sqc, sqr, k1c, k1r, k2c, k2r);

  if (!win)
    return drawn + 5 * distance (sq, king2);
  else
    return won + 50 * (sqr - 2);

}

inline
short
ScoreLoneKing (short side)

     /*
      * Static evaluation when loser has only a king and winner has no pawns or no
      * pieces.
      */

{
//  short ts;
  register short winner, loser, king1, king2, s, i;

  if (mtl[white] == valueK && mtl[black] == valueK)
    return 0;
  UpdateWeights ();
  winner = ((mtl[white] > mtl[black]) ? white : black);
  loser = winner ^ 1;
  king1 = PieceList[winner][0];
  king2 = PieceList[loser][0];

  s = 0;

  if (pmtl[winner] == 0)
    {
      if (emtl[winner] == valueB + valueN)
	s = ScoreKBNK (winner, king1, king2);
      else if (emtl[winner] == valueN + valueN)
	s = 0;
	else if (emtl[winner] < valueR)
       s = 0;
      else
	s = 500 + emtl[winner] - DyingKing[king2] - 2 * distance (king1, king2);
    }
  else
    {
      if (pmtl[winner] == valueP)
	s = ScoreK1PK (side, winner, loser, king1, king2, PieceList[winner][1]);
      else
	for (i = 1; i <= PieceCnt[winner]; i++)
	  s += ScoreKPK (side, winner, loser, king1, king2, PieceList[winner][i]);
    }
  if (side != winner)
    s = 0 - s;
  return(s);
//  ts = ((side == winner) ? s : -s);
//  return (ts);
}

#else // old pre 4pl67 code

short dist_ (short f1, short r1, short f2, short r2)
{
  return distdata [ f1-9+8*r1 ][ f2-9+8*r2 ];
}

short 
kpkwv_ (short pf, short pr, short wf, short wr, short bf, short br)
{

  /*
   *  Don Beal's routine, which was originally in Fortran.  See AICC 2
   */


  const short drawn=0, win=1;
  
  short wbdd, mbpf, blpu;
  short brpu, mwpf, wlpu, wrpu, blpuu, brpuu, wlpuu, wrpuu, md,
    bq, blpuuu, brpuuu, bsd, tbf, sgf, bpp, sdr, sgr, wsd, wsg, ppr, wpp;


  ppr = pr;
  if (pr == 2) { ppr = 3; }
  if (pf != 1) { goto L2; }
  if (bf != 3) { goto L1; }
  if (pr == 7 && wf == 1 && wr == 8 && br > 6) return drawn;
  if (pr == 6 && wf < 4 && wr == 6 && br == 8) return win;
L1:
  if (bf == 1 && br > pr) return drawn;
  if (pr == 7 && bf > 2) return win;
  if (bf <= 3 && br - ppr > 1) return drawn;
  if (wf == 1 && bf == 3 && wr - pr == 1 && br - pr == 1) return drawn;
L2:
  bq = dist_ (bf, br, pf, 8);
  if (bq > 8 - ppr) return win;
  mbpf = bf - pf;
  if (mbpf < 0) { mbpf = -mbpf; }
  bpp = dist_ (bf, br, pf, ppr);
  wpp = dist_ (wf, wr, pf, ppr);
  if (bpp - wpp < -1 && br - pr != mbpf) return drawn;
  if (pf == 1 && pr <= 3 && wf <= 2 && wr == 8 && bf == 4 && br >= 7) return win;
  if (pf != 2 || pr != 6 || bf != 1 || br != 8) { goto L3; }
  if (wf <= 3 && wr == 6) return drawn;
  if (wf == 4 && wr == 8) return drawn;
L3:
  if (pr != 7) { goto L4; }
  if (wr < 8 && wpp == 2 && bq == 0) return win;
  if (wr == 6 && wf == pf && bq == 0) return win;
  if (wr >= 6 && wpp <= 2 && bq != 0) return win;
L4:
  blpuu = dist_ (bf, br, pf-1, pr+2);
  wbdd = dist_ (wf, wr, bf, br-2);
  brpuu = dist_ (bf, br, pf+1, pr+2);
  if (pr != 6) { goto L6; }
  if (dist_ (bf, br, pf+1, pr) > 1 && brpuu > dist_ (wf, wr, pf+1, pr)) return win;
  if (pf == 1) { goto L5; }
  if (blpuu > dist_ (wf, wr, pf-1, pr)) return win;
  if (br == 8 && mbpf == 1 && wbdd == 1) return win;
  if (br > 6 && mbpf == 2 && dist_ (wf, wr, bf, 5) <= 1) return win;
  goto L6;
L5:
  if (wf == 1 && wr == 8 && bf == 2 && br == 6) return drawn;
L6:
  mwpf = wf - pf;
  if (mwpf < 0) { mwpf = -mwpf; }
  if (pr >= 5 && mwpf == 2 && wr == pr && bf == wf && br - pr == 2) return win;
  brpu = dist_ (bf, br, pf+1, pr+1);
  wrpu = dist_ (wf, wr, pf+1, pr+1);
  blpu = dist_ (bf, br, pf-1, pr+1);
  wlpu = dist_ (wf, wr, pf-1, pr+1);
  if (pf == 1 || pr != 5) { goto L7; }
  if (mwpf <= 1 && wr - pr == 1) return win;
  if (wrpu == 1 && brpu > 1) return win;
  if (wr >= 4 && bf == wf && br - pr >= 2 && mbpf == 3) return win;
  if (wlpu == 1 && blpu > 1) return win;
L7:
  if (pr == 2 && br == 3 && mbpf > 1 && dist_ (wf, wr, bf, br+2) <= 1) return win;
  if (wr - pr == 2 && br == pr && mbpf == 1 && mwpf > 1 && (wf - pf) *
      (bf - pf) > 0) return drawn;
  if (pf == 1 && wf == 1 && wr == br && bf > 3) return win;
  sgf = pf - 1;
  if (wf >= pf) { sgf = pf + 1; }
  sgr = wr - (mwpf - 1);
  if (mwpf == 0 && wr > br) { sgr = wr - 1; }
  wsg = dist_ (wf, wr, sgf, sgr);
  if (wr - pr - mwpf > 0 && wr - br >= -1 && bpp - (wsg + (sgr - ppr))
      >= -1 && dist_ (bf, br, sgf, sgr) > wsg) return win;
  md = mbpf - mwpf;
  if (pf != 1 || bf <= 3) { goto L8; }
  sdr = br + (bf - 3);
  if (sdr > 8) { sdr = 8; }
  if (wr > br + 1) { sdr = br; }
  if (sdr <= ppr) { goto L8; }
  wsd = dist_ (wf, wr, 3, sdr);
  bsd = dist_ (bf, br, 3, sdr);
  if (bsd - wsd < -1) return drawn;
  if (bsd <= wsd && md <= 0) return drawn;
L8:
  brpuuu = dist_ (bf, br, pf+1, pr+3);
  if (brpu > wrpu && brpuuu > wrpu && pr - wr != pf - wf) return win;
  if (brpuuu == 0 && wrpu == 1) return win;
  blpuuu = dist_ (bf, br, pf-1, pr+3);
  if (pf == 1) { goto L9; }
  if (blpu > wlpu && blpuuu > wlpu && pr - wr != wf - pf) return win;
  if (blpuuu == 0 && wlpu == 1) return win;
L9:
  wrpuu = dist_ (wf, wr, pf+1, pr+2);
  if (brpuu > wrpuu) return win;
  wlpuu = dist_ (wf, wr, pf-1, pr+2);
  if (pf > 1 && blpuu > wlpuu) return win;
  if (br != pr) { goto L10; }
  if (mwpf <= 2 && wr - pr == -1 && mbpf != 2) return win;
  if (dist_ (wf, wr, bf-1, br+2) <= 1 && bf - pf > 1) return win;
  if (dist_ (wf, wr, bf+1, br+2) <= 1 && bf - pf < -1) return win;
L10:
  if (pf == 1) { goto L11; }
  if (br == pr && mbpf > 1 && dist_ (wf, wr, pf, pr-1) <= 1) return win;
  if (br - pr >= 3 && wbdd == 1) return win;
  if (wr - pr >= 2 && wr < br && md >= 0) return win;
  if (mwpf <= 2 && wr - pr >= 3 && bf != pf && wr - br <= 1) return win;
  if (wr >= pr && br - pr >= 5 && mbpf >= 3 && md >= -1 && ppr == 3) return win;
  if (md >= -1 && pr == 2 && br == 8) return win;
L11:
  tbf = bf - 1;
  if (pf > bf) { tbf = bf + 1; }
  if (mbpf > 1 && br == ppr && dist_ (wf, wr, tbf, wr+2) <= 1) return win;
  if (br == pr && bf - pf == -2 && dist_ (wf, wr, pf+2, pr-1) <= 1) return win;
  if (pf > 2 && br == pr && bf - pf == 2 && dist_ (wf, wr, pf-2, pr-1) <= 1) return win;

  return drawn;
}				/* kpkwv_ */

short 
kpkbv_ (short pf, short pr, short wf, short wr, short bf, short br)
{
  /* Initialized data */

  static short incf[8] =
  {0, 1, 1, 1, 0, -1, -1, -1};
  static short incr[8] =
  {1, 1, 0, -1, -1, -1, 0, 1};

  /* System generated locals */
  short ret_val;

  /* Local variables */
  static short i;
  static short nm, nbf, nbr;

  ret_val = 0;
  nm = 0;
  for (i = 1; i <= 8; ++i)
    {
      nbf = bf + incf[i - 1];
      if (nbf < 1 || nbf > 8) { goto L1; }
      nbr = br + incr[i - 1];
      if (nbr < 1 || nbr > 8) { goto L1; }
      if (dist_ (nbf, nbr, wf, wr) < 2) { goto L1; }
      if (nbf == pf && nbr == pr) { goto L2; }
      if (nbr == pr + 1 && (nbf == pf - 1 || nbf == pf + 1)) { goto L1; }
      ++nm;
      if (kpkwv_ (pf, pr, wf, wr, nbf, nbr) == 0) { goto L2; }
    L1:
      ;
    }
  if (nm > 0) { ret_val = -1; }
L2:
  return ret_val;
}				/* kpkbv_ */


inline
int
ScoreK1PK (short int side,
	   short int winner,
	   short int loser,
	   short int king1,
	   register short int king2,
	   register short int sq)

     /*
      *  We call Don Beal's routine with the necessary parameters and determine
      *  win/draw/loss.  Then we compute the real evaluation which is +-500 for
      *  a win/loss and 10 for a draw, plus some points to lead the computer to
      *  a decisive winning/drawing line.
      */

{
  short s, win, sqc, sqr, k1c, k1r, k2c, k2r;
  const int drawn = 10, won = 500;

#ifdef CACHE
  if (ProbeEETable(side,&s)) return s;
#endif

  sqc = column (sq) + 1;
  sqr = row (sq) + 1;
  k1c = column (king1) + 1;
  k1r = row (king1) + 1;
  k2c = column (king2) + 1;
  k2r = row (king2) + 1;
  if (winner == black)
    {
      sqr = 9 - sqr;
      k1r = 9 - k1r;
      k2r = 9 - k2r;
    }
  if (sqc > 4)
    {
      sqc = 9 - sqc;
      k1c = 9 - k1c;
      k2c = 9 - k2c;
    }

  if (side == winner) win = kpkwv_ (sqc, sqr, k1c, k1r, k2c, k2r);
  else                win = kpkbv_ (sqc, sqr, k1c, k1r, k2c, k2r);

  if (!win)  s = drawn + 5 * distance (sq, king2) - 5*distance(king1,king2);
  else       s = won + 50 * (sqr - 2) + 10*distance(sq,king2);
//  if (!win)  s = drawn + 5 * distance (sq, king2); // old 2.50 way
//  else       s = won + 50 * (sqr - 2); // old 2.50 way

#ifdef CACHE 
  if (PUTVAR) PutInEETable (side, s); 
#endif 

  return s;
}


inline
short int
ScoreLoneKing (ARGSZ int side)

/*
 * Static evaluation when loser has only a king and winner has no pawns or no
 * pieces.
 */

{
    register short winner, loser, king1, king2, s, i;

  if (mtl[white] == valueK && mtl[black] == valueK)
    return 0;
    UpdateWeights ();
    winner = ((mtl[white] > mtl[black]) ? white : black);
    loser = winner ^ 1;
    king1 = PieceList[winner][0];
    king2 = PieceList[loser][0];

    s = 0;

  if (pmtl[winner] == 0)
    {
    if (emtl[winner] == valueB + valueN)
      s = ScoreKBNK (winner, king1, king2);
      else if (emtl[winner] == valueN + valueN || 
               emtl[winner] == valueN || emtl[winner] == valueB)
	s = 0; 
      else
	s = 500 + emtl[winner] - DyingKing[king2] - 2 * distance (king1, king2);
    }
  else {
    if (pmtl[winner] == valueP)
        s = ScoreK1PK (side, winner, loser, king1, king2, PieceList[winner][1]);
      else for (i = 1; i <= PieceCnt[winner]; i++)
        s += ScoreKPK (side, winner, loser, king1, king2, PieceList[winner][i]);
    }

    if (side != winner)
     s = 0 - s;
    return(s);
/*    return ((side == winner) ? s : -s);*/
}

#endif // old eval pre 4pl67 way