lasker-2.2.3/src/ratings.c

   1 /*
   2    Copyright (c) 1993 Richard V. Nash.
   3    Copyright (c) 2000 Dan Papasian
   4    Copyright (C) Andrew Tridgell 2002
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #include "includes.h"
  22
  23 static double Ratings_B_Average;
  24 static double Ratings_B_StdDev;
  25
  26 static double Ratings_S_Average;
  27 static double Ratings_S_StdDev;
  28
  29 static double Ratings_L_Average;
  30 static double Ratings_L_StdDev;
  31
  32 static double Ratings_Bug_Average;
  33 static double Ratings_Bug_StdDev;
  34
  35 static double Ratings_W_Average;
  36 static double Ratings_W_StdDev;
  37
  38
  39 static double Rb_M = 0.0, Rb_S = 0.0, Rb_total = 0.0;
  40 static int Rb_count = 0;
  41
  42 static double Rs_M = 0.0, Rs_S = 0.0, Rs_total = 0.0;
  43 static int Rs_count = 0;
  44
  45 static double Rl_M = 0.0, Rl_S = 0.0, Rl_total = 0.0;
  46 static int Rl_count = 0;
  47
  48 static double Rbug_M = 0.0, Rbug_S = 0.0, Rbug_total = 0.0;
  49 static int Rbug_count = 0;
  50
  51 static double Rw_M = 0.0, Rw_S = 0.0, Rw_total = 0.0;
  52 static int Rw_count = 0;
  53
  54 /*
  55 rateStruct bestS[MAX_BEST];
  56 int numS = 0;
  57 rateStruct bestB[MAX_BEST];
  58 int numB = 0;
  59 rateStruct bestW[MAX_BEST];
  60 int numW = 0;
  61 */
  62
  63 #define MAXHIST 30
  64 #define LOWESTHIST 800
  65 static int sHist[MAXHIST];
  66 static int bHist[MAXHIST];
  67 static int wHist[MAXHIST];
  68 static int lHist[MAXHIST];
  69 static int bugHist[MAXHIST];
  70
  71 static int DisplayRank(int p, param_list param, int showComputers);
  72 static int DisplayTargetRank(int p, char *target, int show, int showComp);
  73 static int ShowFromString(char *s);
  74 static int DisplayRankedPlayers(int p, int start, int end,
  75                                 int show, int showComp);
  76 static int Best(int p, param_list param, int ShowComp);
  77
  78 static int is_active(int Games)
  79 {
  80         return (Games >= PROVISIONAL);
  81 }
  82
  83
  84 static void rating_add(int rating, int type)
  85 {
  86   int which;
  87
  88   which = (rating - LOWESTHIST) / 100;
  89   if (which < 0)
  90     which = 0;
  91   if (which >= MAXHIST)
  92     which = MAXHIST - 1;
  93   if (type == TYPE_BLITZ) {
  94     bHist[which] += 1;
  95     Rb_count++;
  96     Rb_total += rating;
  97     if (Rb_count == 1) {
  98       Rb_M = rating;
  99     } else {
 100       Rb_S = Rb_S + (rating - Rb_M) * (rating - Rb_M);
 101       Rb_M = Rb_M + (rating - Rb_M) / (Rb_count);
 102     }
 103     Ratings_B_StdDev = sqrt(Rb_S / Rb_count);
 104     Ratings_B_Average = Rb_total / (double) Rb_count;
 105   } else if (type == TYPE_WILD || type == TYPE_KNIGHTMATE || type == TYPE_GOTHIC || type == TYPE_CAPABLANCA) {  /* TYPE_WILD */
 106     wHist[which] += 1;
 107     Rw_count++;
 108     Rw_total += rating;
 109     if (Rw_count == 1) {
 110       Rw_M = rating;
 111     } else {
 112       Rw_S = Rw_S + (rating - Rw_M) * (rating - Rw_M);
 113       Rw_M = Rw_M + (rating - Rw_M) / (Rw_count);
 114     }
 115     Ratings_W_StdDev = sqrt(Rw_S / Rw_count);
 116     Ratings_W_Average = Rw_total / (double) Rw_count;
 117   } else if (type == TYPE_LIGHT) {       /* TYPE_LIGHT */
 118     lHist[which] += 1;
 119     Rl_count++;
 120     Rl_total += rating;
 121     if (Rl_count == 1) {
 122       Rl_M = rating;
 123     } else {
 124       Rl_S = Rl_S + (rating - Rl_M) * (rating - Rl_M);
 125       Rl_M = Rl_M + (rating - Rl_M) / (Rl_count);
 126     }
 127     Ratings_L_StdDev = sqrt(Rl_S / Rl_count);
 128     Ratings_L_Average = Rl_total / (double) Rl_count;
 129   } else if (type == TYPE_BUGHOUSE) {       /* TYPE_BUGHOUSE */
 130     bugHist[which] += 1;
 131     Rbug_count++;
 132     Rbug_total += rating;
 133     if (Rbug_count == 1) {
 134       Rbug_M = rating;
 135     } else {
 136       Rbug_S = Rbug_S + (rating - Rbug_M) * (rating - Rbug_M);
 137       Rbug_M = Rbug_M + (rating - Rbug_M) / (Rbug_count);
 138     }
 139     Ratings_Bug_StdDev = sqrt(Rbug_S / Rbug_count);
 140     Ratings_Bug_Average = Rbug_total / (double) Rbug_count;
 141   } else {                      /* TYPE_STAND */
 142     sHist[which] += 1;
 143     Rs_count++;
 144     Rs_total += rating;
 145     if (Rs_count == 1) {
 146       Rs_M = rating;
 147     } else {
 148       Rs_S = Rs_S + (rating - Rs_M) * (rating - Rs_M);
 149       Rs_M = Rs_M + (rating - Rs_M) / (Rs_count);
 150     }
 151     Ratings_S_StdDev = sqrt(Rs_S / Rs_count);
 152     Ratings_S_Average = Rs_total / (double) Rs_count;
 153   }
 154 }
 155
 156 static void rating_remove(int rating, int type)
 157 {
 158   int which;
 159
 160   which = (rating - LOWESTHIST) / 100;
 161   if (which < 0)
 162     which = 0;
 163   if (which >= MAXHIST)
 164     which = MAXHIST - 1;
 165   if (type == TYPE_BLITZ) {
 166     bHist[which] = bHist[which] - 1;
 167     if (bHist[which] < 0)
 168       bHist[which] = 0;
 169     if (Rb_count == 0)
 170       return;
 171     Rb_count--;
 172     Rb_total -= rating;
 173     if (Rb_count == 0) {
 174       Rb_M = 0;
 175       Rb_S = 0;
 176     } else {
 177       Rb_M = Rb_M - (rating - Rb_M) / (Rb_count);
 178       Rb_S = Rb_S - (rating - Rb_M) * (rating - Rb_M);
 179        /* added this 3.11.95 foxbat */ if (Rb_S < 0)
 180         Rb_S = 0;
 181     }
 182     if (Rb_count) {
 183       Ratings_B_StdDev = sqrt(Rb_S / Rb_count);
 184       Ratings_B_Average = Rb_total / (double) Rb_count;
 185     } else {
 186       Ratings_B_StdDev = 0;
 187       Ratings_B_Average = 0;
 188     }
 189   } else if (type == TYPE_WILD || type == TYPE_KNIGHTMATE || type == TYPE_GOTHIC || type == TYPE_CAPABLANCA) {  /* TYPE_WILD */
 190     wHist[which] = wHist[which] - 1;
 191     if (wHist[which] < 0)
 192       wHist[which] = 0;
 193     if (Rw_count == 0)
 194       return;
 195     Rw_count--;
 196     Rw_total -= rating;
 197     if (Rw_count == 0) {
 198       Rw_M = 0;
 199       Rw_S = 0;
 200     } else {
 201       Rw_M = Rw_M - (rating - Rw_M) / (Rw_count);
 202       Rw_S = Rw_S - (rating - Rw_M) * (rating - Rw_M);
 203        /* added this 3.10.95 foxbat */ if (Rw_S < 0)
 204         Rw_S = 0;
 205     }
 206     if (Rw_count) {
 207       Ratings_W_StdDev = sqrt(Rw_S / Rw_count);
 208       Ratings_W_Average = Rw_total / (double) Rw_count;
 209     } else {
 210       Ratings_W_StdDev = 0;
 211       Ratings_W_Average = 0;
 212     }
 213   } else if (type == TYPE_LIGHT) {       /* TYPE_LIGHT */
 214     lHist[which] = lHist[which] - 1;
 215     if (lHist[which] < 0)
 216       lHist[which] = 0;
 217     if (Rl_count == 0)
 218       return;
 219     Rl_count--;
 220     Rl_total -= rating;
 221     if (Rl_count == 0) {
 222       Rl_M = 0;
 223       Rl_S = 0;
 224     } else {
 225       Rl_M = Rl_M - (rating - Rl_M) / (Rl_count);
 226       Rl_S = Rl_S - (rating - Rl_M) * (rating - Rl_M);
 227       if (Rl_S < 0)
 228         Rl_S = 0;
 229     }
 230     if (Rl_count) {
 231       Ratings_L_StdDev = sqrt(Rl_S / Rl_count);
 232       Ratings_L_Average = Rl_total / (double) Rl_count;
 233     } else {
 234       Ratings_L_StdDev = 0;
 235       Ratings_L_Average = 0;
 236     }
 237   } else if (type == TYPE_BUGHOUSE) {       /* TYPE_BUGHOUSE */
 238     bugHist[which] = bugHist[which] - 1;
 239     if (bugHist[which] < 0)
 240       bugHist[which] = 0;
 241     if (Rbug_count == 0)
 242       return;
 243     Rbug_count--;
 244     Rbug_total -= rating;
 245     if (Rbug_count == 0) {
 246       Rbug_M = 0;
 247       Rbug_S = 0;
 248     } else {
 249       Rbug_M = Rbug_M - (rating - Rbug_M) / (Rbug_count);
 250       Rbug_S = Rbug_S - (rating - Rbug_M) * (rating - Rbug_M);
 251       if (Rbug_S < 0)
 252         Rbug_S = 0;
 253     }
 254     if (Rbug_count) {
 255       Ratings_Bug_StdDev = sqrt(Rbug_S / Rbug_count);
 256       Ratings_Bug_Average = Rbug_total / (double) Rbug_count;
 257     } else {
 258       Ratings_Bug_StdDev = 0;
 259       Ratings_Bug_Average = 0;
 260     }
 261   } else {                      /* TYPE_STAND */
 262     sHist[which] = sHist[which] - 1;
 263     if (sHist[which] < 0)
 264       sHist[which] = 0;
 265     if (Rs_count == 0)
 266       return;
 267     Rs_count--;
 268     Rs_total -= rating;
 269     if (Rs_count == 0) {
 270       Rs_M = 0;
 271       Rs_S = 0;
 272     } else {
 273       Rs_M = Rs_M - (rating - Rs_M) / (Rs_count);
 274       Rs_S = Rs_S - (rating - Rs_M) * (rating - Rs_M);
 275        /* added this 3.10.95 foxbat */ if (Rs_S < 0)
 276         Rs_S = 0;
 277     }
 278     if (Rs_count) {
 279       Ratings_S_StdDev = sqrt(Rs_S / Rs_count);
 280       Ratings_S_Average = Rs_total / (double) Rs_count;
 281     } else {
 282       Ratings_S_StdDev = 0;
 283       Ratings_S_Average = 0;
 284     }
 285   }
 286 }
 287
 288 static void load_ratings(void)
 289 {
 290         FILE *fp;
 291         int i;
 292
 293         fp = fopen_p("%s/newratingsV%d_data", "r", STATS_DIR, STATS_VERSION);
 294         if (!fp) {
 295                 d_printf( "CHESSD: Can't read ratings data!\n");
 296                 return;
 297         }
 298
 299         fscanf(fp, "%lf %lf %lf %d", &Rb_M, &Rb_S, &Rb_total, &Rb_count);
 300         fscanf(fp, "%lf %lf %lf %d", &Rs_M, &Rs_S, &Rs_total, &Rs_count);
 301         fscanf(fp, "%lf %lf %lf %d", &Rw_M, &Rw_S, &Rw_total, &Rw_count);
 302         fscanf(fp, "%lf %lf %lf %d", &Rl_M, &Rl_S, &Rl_total, &Rl_count);
 303
 304         for (i = 0; i < MAXHIST; i++) {
 305                 fscanf(fp, "%d %d %d %d", &sHist[i], &bHist[i], &wHist[i], &lHist[i]);
 306         }
 307         fclose(fp);
 308         if (Rs_count) {
 309                 Ratings_S_StdDev = sqrt(Rs_S / Rs_count);
 310                 Ratings_S_Average = Rs_total / (double) Rs_count;
 311         } else {
 312                 Ratings_S_StdDev = 0;
 313                 Ratings_S_Average = 0;
 314         }
 315         if (Rb_count) {
 316                 Ratings_B_StdDev = sqrt(Rb_S / Rb_count);
 317                 Ratings_B_Average = Rb_total / (double) Rb_count;
 318         } else {
 319                 Ratings_B_StdDev = 0;
 320                 Ratings_B_Average = 0;
 321         }
 322         if (Rw_count) {
 323                 Ratings_W_StdDev = sqrt(Rw_S / Rw_count);
 324                 Ratings_W_Average = Rw_total / (double) Rw_count;
 325         } else {
 326                 Ratings_W_StdDev = 0;
 327                 Ratings_W_Average = 0;
 328         }
 329         if (Rl_count) {
 330                 Ratings_L_StdDev = sqrt(Rl_S / Rl_count);
 331                 Ratings_L_Average = Rl_total / (double) Rl_count;
 332         } else {
 333                 Ratings_L_StdDev = 0;
 334                 Ratings_L_Average = 0;
 335         }
 336 }
 337
 338 static void save_ratings(void)
 339 {
 340         FILE *fp;
 341         int i;
 342
 343         fp = fopen_p("%s/newratingsV%d_data", "w", STATS_DIR,STATS_VERSION);
 344         if (!fp) {
 345                 d_printf( "CHESSD: Can't write ratings data!\n");
 346                 return;
 347         }
 348
 349         fprintf(fp, "%10f %10f %10f %d\n", Rb_M, Rb_S, Rb_total, Rb_count);
 350         fprintf(fp, "%10f %10f %10f %d\n", Rs_M, Rs_S, Rs_total, Rs_count);
 351         fprintf(fp, "%10f %10f %10f %d\n", Rw_M, Rw_S, Rw_total, Rw_count);
 352         fprintf(fp, "%10f %10f %10f %d\n", Rl_M, Rl_S, Rl_total, Rl_count);
 353
 354         for (i = 0; i < MAXHIST; i++) {
 355                 fprintf(fp, "%d %d %d %d\n", sHist[i], bHist[i], wHist[i], lHist[i]);
 356         }
 357         fclose(fp);
 358 }
 359
 360 static void zero_stats(void)
 361 {
 362         int i;
 363         for (i = 0; i < MAXHIST; i++) {
 364                 sHist[i] = 0;
 365                 bHist[i] = 0;
 366                 wHist[i] = 0;
 367                 lHist[i] = 0;
 368         }
 369         Rb_M = 0.0, Rb_S = 0.0, Rb_total = 0.0;
 370         Rb_count = 0;
 371
 372         Rs_M = 0.0, Rs_S = 0.0, Rs_total = 0.0;
 373         Rs_count = 0;
 374
 375         Rw_M = 0.0, Rw_S = 0.0, Rw_total = 0.0;
 376         Rw_count = 0;
 377
 378         Rl_M = 0.0, Rl_S = 0.0, Rl_total = 0.0;
 379         Rl_count = 0;
 380 }
 381
 382 void ratings_init(void)
 383 {
 384         zero_stats();
 385         load_ratings();
 386 }
 387
 388 static int Round (double x)
 389 {
 390   return (x < 0   ?   (int) (x - 0.5)   :   (int) (x + 0.5));
 391 }
 392
 393 /*  Constants for Glicko system */
 394 #define Gd 1.483
 395 #define Gv 0.0005828166666667  /* (0.187)^2 / 60 */
 396 #define Gr0 1720
 397 #define Gs0 350
 398 #define Gq 0.00575646273249       /* ln(10.0)/400.0 */
 399 #define Gp 0.000010072398601964   /* (3 * Gq / PI)^2 */
 400 #define GBq 0.00287823136624      /* ln(10.0)/800.0 */
 401 #define GBp (9 * GBq * GBq / (3.141592653589 * 3.141592653589))
 402 /* End of Glicko system variables */
 403
 404 static double Gf(double ss)
 405 {
 406   return (1.0 / sqrt(1.0 + Gp * ss * ss));
 407 }
 408
 409 /* Confusing but economical: calculate error and attenuation function together */
 410 static double GE(int r, int rr, double ss, double *fss)
 411 {
 412   *fss = Gf(ss);
 413   return (1.0 / (1.0 + pow(10.0, (rr - r) * (*fss) / 400.0)));
 414 }
 415
 416 static double GBf(double sp, double ss, double ssp)
 417 {
 418   return (1.0 / sqrt(1.0 + GBp * (ss*ss + sp*sp + ssp*ssp)));
 419 }
 420
 421 /* Confusing but economical: calculate error and attenuation function together */
 422 static double GBE(int r, int rp, int rr, int rrp,
 423                    double sp, double ss, double ssp, double *fss)
 424 {
 425   *fss = GBf(sp, ss, ssp);
 426   return (1.0 / (1.0 + pow(10.0, (rr + rrp - r - rp) * (*fss) / 800.0)));
 427 }
 428
 429 double current_sterr(double s, long t)
 430 {
 431   double new;
 432
 433   if (t < 0)
 434     t = 0;                      /* this shouldn't happen */
 435   new = sqrt(s * s + Gd * Gd * log(1.0 + t / 60.0));    /* log formula */
 436   /*  new = sqrt(s * s + Gv * t);  */                /* linear formula */
 437   if (new > Gs0)
 438     new = Gs0;
 439   return (new);
 440 }
 441
 442 static void UpdateStats(struct statistics *p_stats, int *r, double *s, int now)
 443 {
 444   /* Calculate effective pre-game sterrs.  ltime==0 implies never had sterr. */
 445
 446   *s = current_sterr(p_stats->sterr, now - p_stats->ltime);
 447
 448   /* pre-game ratings */
 449   *r = (p_stats->rating == 0 && p_stats->num == 0)  ?  Gr0
 450                                                     :  p_stats->rating;
 451   return;
 452 }
 453
 454 static void GetCurrentStats (int p, int *r, double *s, int *new,
 455                       int *rPart, double *sPart, int type, int now)
 456 {
 457   struct player *pp = &player_globals.parray[p];
 458   struct statistics *p_stats = NULL;
 459   struct statistics *part_stats;     /* for bughouse. */
 460
 461   switch (type) {
 462     case TYPE_BLITZ:
 463       p_stats = &pp->b_stats;
 464       break;
 465     case TYPE_STAND:
 466       p_stats = &pp->s_stats;
 467       break;
 468     case TYPE_WILD:
 469     case TYPE_KNIGHTMATE:
 470     case TYPE_CAPABLANCA:
 471     case TYPE_GOTHIC:
 472       p_stats = &pp->w_stats;
 473       break;
 474     case TYPE_LIGHT:
 475       p_stats = &pp->l_stats;
 476       break;
 477     case TYPE_BUGHOUSE:
 478       p_stats = &pp->bug_stats;
 479       part_stats = &player_globals.parray[pp->partner].bug_stats;
 480       UpdateStats(part_stats, rPart, sPart, now);
 481       break;
 482   }
 483   /* Calculate effective pre-game sterrs.  ltime==0 implies never had sterr. */
 484   UpdateStats(p_stats, r, s, now);
 485   if (p_stats->rating == 0 && p_stats->num == 0)
 486     *new = 1;
 487   else *new = 0;
 488 }
 489
 490 /* Calculates new rating and standard error.  By vek.  The person       */
 491 /*   who invented the ratings system is Mark E. Glickman, Ph.D.         */
 492 /*   His e-mail address is glickman@hustat.harvard.edu as of April '95. */
 493 /*   Postscript copy of the note I coded this from should be available  */
 494 /*   for ftp from ics.onenet.net, if not elsewhere.                     */
 495
 496 void rating_sterr_delta(int p1, int p2, int type, int gtime, int result,
 497                                 int *deltarating, double *newsterr)
 498 {
 499
 500   double s1, s2, s1part, s2part;
 501   int r1, r2, r1part, r2part, new;      /* Initial sterrs and ratings */
 502   double q, E, fs2, denominator, GK, w; /* Parts of fancy formulas */
 503   double delta;                         /* Result to return */
 504
 505   GetCurrentStats (p2, &r2, &s2, &new, &r2part, &s2part, type, gtime);
 506   GetCurrentStats (p1, &r1, &s1, &new, &r1part, &s1part, type, gtime);
 507
 508   /* now crunch */
 509   if (result == RESULT_WIN) {
 510     w = 1.0;
 511   } else if (result == RESULT_DRAW) {
 512     w = 0.5;
 513   } else {
 514     w = 0.0;
 515   }
 516   if (type != TYPE_BUGHOUSE) {
 517     q = Gq;
 518     E = GE(r1, r2, s2, &fs2);   /* side effect: calculate fs2 */
 519   } else {
 520     q = GBq;
 521     E = GBE(r1, r1part, r2, r2part, s1part, s2, s2part, &fs2);
 522   }
 523   denominator = 1.0 / (s1 * s1) + q * q * fs2 * fs2 * E * (1.0 - E);
 524   GK = q * fs2 / denominator;
 525
 526   delta = GK * (w - E);
 527   if (new)
 528     *deltarating = Round(Gr0 + delta);
 529   else
 530     *deltarating = Round(delta);        /* Returned values: deltarating,
 531                                            newsterr */
 532   *newsterr = 1.0 / sqrt(denominator);
 533 }
 534
 535 int rating_update(int g, int link_game)
 536 {
 537   int wDelta, bDelta;
 538   double wSigma, bSigma;        /* vek */
 539
 540   int wRes, bRes;
 541   struct statistics *w_stats;
 542   struct statistics *b_stats;
 543
 544   int gtime;
 545
 546   int inprogress = (g == player_globals.parray[game_globals.garray[g].black].game);
 547   /* if this is adjudication of stored game, be quiet about ratings change */
 548
 549   if (game_globals.garray[g].type == TYPE_BLITZ) {
 550     w_stats = &player_globals.parray[game_globals.garray[g].white].b_stats;
 551     b_stats = &player_globals.parray[game_globals.garray[g].black].b_stats;
 552   } else if (game_globals.garray[g].type == TYPE_STAND) {
 553     w_stats = &player_globals.parray[game_globals.garray[g].white].s_stats;
 554     b_stats = &player_globals.parray[game_globals.garray[g].black].s_stats;
 555   } else if (game_globals.garray[g].type == TYPE_WILD
 556           || game_globals.garray[g].type == TYPE_KNIGHTMATE
 557           || game_globals.garray[g].type == TYPE_GOTHIC
 558           || game_globals.garray[g].type == TYPE_CAPABLANCA) {
 559     w_stats = &player_globals.parray[game_globals.garray[g].white].w_stats;
 560     b_stats = &player_globals.parray[game_globals.garray[g].black].w_stats;
 561   } else if (game_globals.garray[g].type == TYPE_LIGHT) {
 562     w_stats = &player_globals.parray[game_globals.garray[g].white].l_stats;
 563     b_stats = &player_globals.parray[game_globals.garray[g].black].l_stats;
 564   } else if (game_globals.garray[g].type == TYPE_BUGHOUSE) {
 565     w_stats = &player_globals.parray[game_globals.garray[g].white].bug_stats;
 566     b_stats = &player_globals.parray[game_globals.garray[g].black].bug_stats;
 567   } else {
 568     d_printf( "CHESSD: Can't update untimed ratings!\n");
 569     return -1;
 570   }
 571
 572   switch (game_globals.garray[g].result) {
 573   case END_CHECKMATE:
 574   case END_RESIGN:
 575   case END_FLAG:
 576   case END_ADJWIN:
 577     if (game_globals.garray[g].winner == WHITE) {
 578       wRes = RESULT_WIN;
 579       bRes = RESULT_LOSS;
 580     } else {
 581       bRes = RESULT_WIN;
 582       wRes = RESULT_LOSS;
 583     }
 584     break;
 585   case END_AGREEDDRAW:
 586   case END_REPETITION:
 587   case END_50MOVERULE:
 588   case END_STALEMATE:
 589   case END_NOMATERIAL:
 590   case END_BOTHFLAG:
 591   case END_ADJDRAW:
 592   case END_FLAGNOMATERIAL:
 593     wRes = bRes = RESULT_DRAW;
 594     break;
 595   default:
 596     d_printf( "CHESSD: Update undecided game %d?\n", game_globals.garray[g].result);
 597     return -1;
 598   }
 599   /* Use end time, not start time; important for adjourned games. */
 600   /*  gtime = untenths(game_globals.garray[g].timeOfStart); */
 601   gtime = time(0);
 602   rating_sterr_delta(game_globals.garray[g].white, game_globals.garray[g].black,
 603                      game_globals.garray[g].type, gtime, wRes,
 604                      &wDelta, &wSigma);
 605
 606   rating_sterr_delta(game_globals.garray[g].black, game_globals.garray[g].white,
 607                      game_globals.garray[g].type, gtime, bRes,
 608                      &bDelta, &bSigma);
 609
 610   /* hersco, 1/23/96: We now know rating changes for these players;
 611      update partners' game. */
 612   if (link_game >= 0) {
 613     game_globals.garray[link_game].winner = CToggle(game_globals.garray[g].winner);
 614     game_globals.garray[link_game].result = game_globals.garray[g].result;
 615     rating_update (link_game, -1);    /* but don't recurse any deeper. */
 616   }
 617   /* vek: Update time of last rated game played, for future ratings calcs. */
 618   /* Kept independently for blitz and standard.                       */
 619   w_stats->ltime = gtime;
 620   b_stats->ltime = gtime;
 621   /* end vek add 4/5/95 */
 622
 623   if (wRes == RESULT_WIN) {
 624     w_stats->win++;
 625   } else if (wRes == RESULT_LOSS) {
 626     w_stats->los++;
 627   } else {
 628     w_stats->dra++;
 629   }
 630   w_stats->num++;
 631   if (bRes == RESULT_WIN) {
 632     b_stats->win++;
 633   } else if (bRes == RESULT_LOSS) {
 634     b_stats->los++;
 635   } else {
 636     b_stats->dra++;
 637   }
 638   b_stats->num++;
 639   rating_remove(w_stats->rating, game_globals.garray[g].type);
 640   rating_remove(b_stats->rating, game_globals.garray[g].type);
 641
 642   if (inprogress) {
 643     pprintf(game_globals.garray[g].white, "%s rating adjustment: %d ",
 644             TypeStrings[game_globals.garray[g].type], w_stats->rating);
 645     pprintf(game_globals.garray[g].black, "%s rating adjustment: %d ",
 646             TypeStrings[game_globals.garray[g].type], b_stats->rating);
 647   }
 648   if (wDelta < -1000) {
 649     pprintf(game_globals.garray[g].white, "not changed due to bug (way too small)! sorry!\n");
 650     d_printf( "CHESSD: Got too small ratings bug for %s (w) vs. %s\n",
 651             player_globals.parray[game_globals.garray[g].white].login, player_globals.parray[game_globals.garray[g].black].login);
 652   } else if (wDelta > 3000) {
 653     pprintf(game_globals.garray[g].white, "not changed due to bug (way too big)! sorry!\n");
 654     d_printf( "CHESSD: Got too big ratings bug for %s (w) vs. %s\n",
 655             player_globals.parray[game_globals.garray[g].white].login, player_globals.parray[game_globals.garray[g].black].login);
 656   } else {
 657     w_stats->rating += wDelta;
 658     w_stats->sterr = wSigma;
 659   }
 660
 661   if (bDelta < -1000) {
 662     pprintf(game_globals.garray[g].black, "not changed due to bug (way too small)! sorry! ");
 663     d_printf( "CHESSD: Got too small ratings bug for %s (b) vs. %s\n",
 664             player_globals.parray[game_globals.garray[g].black].login, player_globals.parray[game_globals.garray[g].white].login);
 665   } else if (bDelta > 3000) {
 666     pprintf(game_globals.garray[g].black, "not changed due to bug (way too big)! sorry! ");
 667     d_printf( "CHESSD: Got too big ratings bug for %s (b) vs. %s\n",
 668             player_globals.parray[game_globals.garray[g].black].login, player_globals.parray[game_globals.garray[g].white].login);
 669   } else {
 670     b_stats->rating += bDelta;
 671     b_stats->sterr = bSigma;
 672   }                             /* error messages down to vek */
 673
 674   rating_add(w_stats->rating, game_globals.garray[g].type);
 675   rating_add(b_stats->rating, game_globals.garray[g].type);
 676
 677   if ((w_stats->rating > w_stats->best) && (is_active(w_stats->num))) {
 678     w_stats->best = w_stats->rating;
 679     w_stats->whenbest = time(NULL);
 680   }
 681   if ((b_stats->rating > b_stats->best) && (is_active(b_stats->num))) {
 682     b_stats->best = b_stats->rating;
 683     b_stats->whenbest = time(NULL);
 684   }
 685
 686 /* ratings are saved later - DAV */
 687
 688 /* foxbat 3.11.95 */
 689   if (game_globals.garray[g].type == TYPE_BLITZ) {
 690     Rb_count++;
 691     Rb_total += (w_stats->rating + b_stats->rating) / 2.0;
 692   } else if (game_globals.garray[g].type == TYPE_STAND) {
 693     Rs_count++;
 694     Rs_total += (w_stats->rating + b_stats->rating) / 2.0;
 695   } else if (game_globals.garray[g].type == TYPE_LIGHT) {
 696     Rl_count++;
 697     Rl_total += (w_stats->rating + b_stats->rating) / 2.0;
 698   } else if (game_globals.garray[g].type == TYPE_BUGHOUSE) {
 699     Rbug_count++;
 700     Rbug_total += (w_stats->rating + b_stats->rating) / 2.0;
 701   } else if (game_globals.garray[g].type == TYPE_WILD
 702           || game_globals.garray[g].type == TYPE_KNIGHTMATE
 703           || game_globals.garray[g].type == TYPE_CAPABLANCA
 704           || game_globals.garray[g].type == TYPE_GOTHIC) {
 705     Rw_count++;
 706     Rw_total += (w_stats->rating + b_stats->rating) / 2.0;
 707   }
 708 /* end add */
 709   if (inprogress) {
 710     pprintf(game_globals.garray[g].white, "--> %d\n", w_stats->rating);
 711     pprintf(game_globals.garray[g].black, "--> %d\n", b_stats->rating);
 712   }
 713   save_ratings();
 714   UpdateRank(game_globals.garray[g].type, player_globals.parray[game_globals.garray[g].white].name,
 715              w_stats, player_globals.parray[game_globals.garray[g].white].name);
 716   UpdateRank(game_globals.garray[g].type, player_globals.parray[game_globals.garray[g].black].name,
 717              b_stats, player_globals.parray[game_globals.garray[g].black].name);
 718   return 0;
 719 }
 720
 721 static void ShowAssess (int p, int p1, int p2, int type1, int type2)
 722 {
 723   int p3, p4;
 724   int win1, win2, win3, win4;
 725   int draw1, draw2, draw3, draw4;
 726   int loss1, loss2, loss3, loss4;
 727   double newsterr1, newsterr2, newsterr3, newsterr4;
 728   int nowtime = time(0);
 729   char line[100];        /* should never need any more than 80. */
 730
 731   if (type1 == TYPE_BUGHOUSE) {
 732     p3 = player_globals.parray[p1].partner;
 733     p4 = player_globals.parray[p2].partner;
 734     type2 = type1;
 735     if (!CheckPFlag(p3, PFLAG_REG) || !CheckPFlag(p4, PFLAG_REG)) {
 736       pprintf (p, "Bughouse with unregistered partners cannot be rated.\n");
 737       return;
 738     }
 739   } else {
 740     p3 = p1;
 741     p4 = p2;
 742   }
 743   rating_sterr_delta(p1, p2, type1, nowtime, RESULT_WIN, &win1, &newsterr1);
 744   rating_sterr_delta(p1, p2, type1, nowtime, RESULT_DRAW, &draw1, &newsterr1);
 745   rating_sterr_delta(p1, p2, type1, nowtime, RESULT_LOSS, &loss1, &newsterr1);
 746   rating_sterr_delta(p2, p1, type1, nowtime, RESULT_WIN, &win2, &newsterr2);
 747   rating_sterr_delta(p2, p1, type1, nowtime, RESULT_DRAW, &draw2, &newsterr2);
 748   rating_sterr_delta(p2, p1, type1, nowtime, RESULT_LOSS, &loss2, &newsterr2);
 749
 750   if (type2 >= 0) {
 751     rating_sterr_delta(p3,p4, type2, nowtime,RESULT_WIN, &win3, &newsterr3);
 752     rating_sterr_delta(p3,p4, type2, nowtime,RESULT_DRAW, &draw3, &newsterr3);
 753     rating_sterr_delta(p3,p4, type2, nowtime,RESULT_LOSS, &loss3, &newsterr3);
 754     rating_sterr_delta(p4,p3, type2, nowtime,RESULT_WIN, &win4, &newsterr4);
 755     rating_sterr_delta(p4,p3, type2, nowtime,RESULT_DRAW, &draw4, &newsterr4);
 756     rating_sterr_delta(p4,p3, type2, nowtime,RESULT_LOSS, &loss4, &newsterr4);
 757   }
 758   sprintf (line, "%7s", "");
 759   if (type1 != TYPE_BUGHOUSE) {
 760     CenterText (&line[7], TypeStrings[type1], 35, 1);
 761     if (type2 >= 0) {
 762       strcat (line, "  ");
 763       CenterText (&line[44], TypeStrings[type2], 35, 0);
 764     }
 765   }
 766   else {
 767     CenterText (&line[7], "Bughouse", 72, 0);
 768   }
 769   pprintf (p, "\n%s\n", line);
 770
 771   sprintf (line, "%7s", "");
 772   CenterText (&line[7], player_globals.parray[p1].name, 17, 1);
 773   strcat (line, " ");
 774   CenterText (&line[25], player_globals.parray[p2].name, 17, 1);
 775   if (type2 >= 0) {
 776     strcat (line, "  ");
 777     CenterText (&line[44], player_globals.parray[p3].name, 17, 1);
 778     strcat (line, " ");
 779     CenterText (&line[62], player_globals.parray[p4].name, 17, 0);
 780   }
 781   pprintf (p, "%s\n", line);
 782   pprintf (p, "%7s (%4s RD %5.1f) ",
 783            "", ratstrii(GetRating(&player_globals.parray[p1], type1), p1),
 784                GetRD(&player_globals.parray[p1], type1));
 785   pprintf (p, "  (%4s RD %5.1f)",
 786               ratstrii(GetRating(&player_globals.parray[p2], type1), p2),
 787               GetRD(&player_globals.parray[p2], type1));
 788   if (type2 >= 0) {
 789     pprintf (p, "    (%4s RD %5.1f)",
 790                 ratstrii(GetRating(&player_globals.parray[p3], type2), p3),
 791                 GetRD(&player_globals.parray[p3], type2));
 792     pprintf (p, "   (%4s RD %5.1f)",
 793                 ratstrii(GetRating(&player_globals.parray[p4], type2), p4),
 794                 GetRD(&player_globals.parray[p4], type2));
 795   }
 796   pprintf (p, "\n%7s%9d %17d", "Win:", win1, loss2);
 797   if (type2 >= 0)
 798     pprintf (p, "  %17d %17d", win3, loss4);
 799   pprintf (p, "\n%7s%9d %17d", "Draw:", draw1, draw2);
 800   if (type2 >= 0)
 801     pprintf (p, "  %17d %17d", draw3, draw4);
 802   pprintf (p, "\n%7s%9d %17d", "Loss:", loss1, win2);
 803   if (type2 >= 0)
 804     pprintf (p, "  %17d %17d", loss3, win4);
 805   pprintf (p, "\n%7s%10.1f %17.1f", "New RD:", newsterr1, newsterr2);
 806   if (type2 >= 0)
 807     pprintf (p, "  %17.1f %17.1f", newsterr3, newsterr4);
 808   pprintf(p, "\n");
 809 }
 810
 811 int com_assess(int p, param_list param)
 812 {
 813   struct player *pp = &player_globals.parray[p];
 814   int p1 = p, p2, g, gametype = -1;
 815   int p1_connected = 1, p2_connected = 1;
 816
 817 /* Hawk: Now assess can be used with players not  */
 818 /*       logged on -- I wonder if anyone doesn't  */
 819 /*       get just a bit confused here :)          */
 820
 821   if (param[0].type == TYPE_NULL) {
 822     g = pp->game;
 823     if (g < 0) {
 824       pprintf(p, "You are not playing or examining a game.\n");
 825       return COM_OK;
 826     } else if ((game_globals.garray[g].status == GAME_EXAMINE) || (game_globals.garray[g].status == GAME_SETUP)) {
 827       gametype = game_globals.garray[g].type;
 828       if (!strcmp(game_globals.garray[g].black_name, pp->name)) {
 829         if (game_globals.garray[g].rated) {
 830           pcommand(p, "assess %s %s %s\n", game_globals.garray[g].black_name,
 831                       game_globals.garray[g].white_name, TypeStrings[gametype]);
 832           return COM_OK_NOPROMPT;
 833         } else {
 834           pprintf(p, "You are not involved in a rated game.\n");
 835         }
 836       } else {
 837         if (game_globals.garray[g].rated) {
 838           pcommand(p, "assess %s %s %s\n", game_globals.garray[g].white_name,
 839                       game_globals.garray[g].black_name, TypeStrings[gametype]);
 840           return COM_OK_NOPROMPT;
 841         } else {
 842           pprintf(p, "You are not involved in a rated game.\n");
 843         }
 844       }
 845       return COM_OK;
 846     } else {
 847       p2 = pp->opponent;
 848       gametype = game_globals.garray[g].type;
 849     }
 850   } else if (param[0].type == TYPE_INT) {
 851     if (param[1].type != TYPE_NULL) {
 852       pprintf(p, "Assess <game number> cannot use other parameters.\n");
 853       return COM_OK;
 854     }
 855     g = param[0].val.integer - 1;
 856     if (g < 0 || g >= game_globals.g_num) {
 857       pprintf (p, "There is no game %d.\n", g+1);
 858       return COM_OK;
 859     }
 860     gametype = game_globals.garray[g].type;
 861     pcommand(p, "assess %s %s %s\n", game_globals.garray[g].white_name,
 862                  game_globals.garray[g].black_name, TypeStrings[gametype]);
 863     return COM_OK_NOPROMPT;
 864   } else {
 865     if (!FindPlayer(p, param[0].val.word, &p2, &p2_connected)) {
 866       pprintf(p, "No user named \"%s\" was found.\n", param[0].val.word);
 867       return COM_OK;
 868     }
 869     if (param[1].type != TYPE_NULL) {
 870       p1 = p2;
 871       p1_connected = p2_connected;
 872       if (!FindPlayer(p, param[1].val.word, &p2, &p2_connected)) {
 873         pprintf(p, "No user named \"%s\" was found.\n", param[1].val.word);
 874         if (!p1_connected)
 875           player_remove(p1);
 876         return COM_OK;
 877       }
 878       if (param[2].type == TYPE_WORD) {
 879         param[2].val.word[0] = toupper(param[2].val.word[0]);
 880         for (gametype = 0; gametype < NUM_GAMETYPES; gametype++)
 881           if (!strcmp(TypeStrings[gametype], param[2].val.word))
 882             break;
 883       }
 884     }
 885   }
 886   if (gametype >= NUM_GAMETYPES) {
 887     pprintf(p, "There is no game type %s.\n", param[2].val.word);
 888   } else if (p1 == p2) {
 889     pprintf(p, "You can't assess the same players.\n");
 890   } else if (!CheckPFlag(p1, PFLAG_REG) || !CheckPFlag(p2, PFLAG_REG)) {
 891     pprintf(p, "You can only assess games between registered players.\n");
 892   } else if (gametype >= 0) {
 893     if (gametype == TYPE_BUGHOUSE
 894         && (player_globals.parray[p1].partner < 0 || player_globals.parray[p2].partner < 0)) {
 895       pprintf(p, "You can only assess bughouse games if both players have partners.\n");
 896     } else if (gametype == TYPE_UNTIMED || gametype == TYPE_NONSTANDARD) {
 897       pprintf (p, "%s games are never rated.\n", TypeStrings[gametype]);
 898     } else {
 899       ShowAssess (p, p1, p2, gametype, -1);
 900     }
 901   } else {
 902     ShowAssess (p, p1, p2, TYPE_BLITZ, TYPE_STAND);
 903     ShowAssess (p, p1, p2, TYPE_LIGHT, TYPE_WILD);
 904     if (player_globals.parray[p1].partner >= 0 && player_globals.parray[p2].partner >= 0
 905         && player_globals.parray[p1].partner != p2)
 906       ShowAssess (p, p1, p2, TYPE_BUGHOUSE, TYPE_BUGHOUSE);
 907   }
 908   if (!p1_connected)
 909       player_remove(p1);
 910   if (!p2_connected)
 911     player_remove(p2);
 912   return COM_OK;
 913 }
 914
 915
 916 int com_best(int p, param_list param)
 917 {
 918   return Best(p, param, 1);
 919 }
 920
 921 int com_hbest(int p, param_list param)
 922 {
 923   return Best(p, param, 0);
 924 }
 925
 926 #if 0
 927 int com_best(int p, param_list param)
 928 {
 929   int i;
 930
 931   pprintf(p, "Standard                Blitz                   Wild\n");
 932   for (i = 0; i < MAX_BEST; i++) {
 933     if ((i >= numS) && (i >= numB))
 934       break;
 935     if (i < numS) {
 936       pprintf(p, "%4d %-17s  ", bestS[i].rating, bestS[i].name);
 937     } else {
 938       pprintf(p, "                        ");
 939     }
 940     if (i < numB) {
 941       pprintf(p, "%4d %-17s  ", bestB[i].rating, bestB[i].name);
 942     } else {
 943       pprintf(p, "                        ");
 944     }
 945     if (i < numW) {
 946       pprintf(p, "%4d %-17s\n", bestW[i].rating, bestW[i].name);
 947     } else {
 948       pprintf(p, "\n");
 949     }
 950   }
 951   return COM_OK;
 952 }
 953 #endif
 954
 955 int com_statistics(int p, param_list param)
 956 {
 957   pprintf(p, "                Standard       Blitz   Lightning        Wild\n");
 958   pprintf(p, "average:         %7.2f     %7.2f     %7.2f     %7.2f\n", Ratings_S_Average, Ratings_B_Average, Ratings_L_Average, Ratings_W_Average);
 959   pprintf(p, "std dev:         %7.2f     %7.2f     %7.2f     %7.2f\n", Ratings_S_StdDev, Ratings_B_StdDev, Ratings_L_StdDev, Ratings_W_StdDev);
 960   pprintf(p, "number :      %7d     %7d     %7d     %7d\n", Rs_count, Rb_count,  Rl_count, Rw_count);
 961   return COM_OK;
 962 }
 963
 964 int com_fixrank(int p, param_list param)
 965 {
 966   int p1, connected;
 967
 968   if (!FindPlayer(p, param[0].val.word, &p1, &connected))
 969     return COM_OK;
 970   UpdateRank(TYPE_BLITZ, player_globals.parray[p1].name, &player_globals.parray[p1].b_stats,
 971              player_globals.parray[p1].name);
 972   UpdateRank(TYPE_STAND, player_globals.parray[p1].name, &player_globals.parray[p1].s_stats,
 973              player_globals.parray[p1].name);
 974   UpdateRank(TYPE_WILD, player_globals.parray[p1].name, &player_globals.parray[p1].w_stats,
 975              player_globals.parray[p1].name);
 976   if (!connected)
 977     player_remove(p1);
 978   return COM_OK;
 979 }
 980
 981 int com_rank(int p, param_list param)
 982 {
 983         return DisplayRank(p, param, 1);
 984 }
 985
 986 int com_hrank(int p, param_list param)
 987 {
 988   return DisplayRank(p, param, 0);
 989 }
 990
 991 static int DisplayRank(int p, param_list param, int showComputers)
 992 {
 993   struct player *pp = &player_globals.parray[p];
 994   int start, end, target, connected;
 995   int show = SHOW_BLITZ | SHOW_STANDARD | SHOW_WILD;
 996
 997   if (param[0].type == TYPE_NULL) {
 998     DisplayTargetRank(p, pp->name, show, showComputers);
 999     return COM_OK;
1000   } else if (isdigit(param[0].val.word[0])) {
1001     end = -1;
1002     sscanf(param[0].val.word, "%d-%d", &start, &end);
1003     if (end > 0 && (param[1].type != TYPE_NULL))
1004       show = ShowFromString(param[1].val.word);
1005     DisplayRankedPlayers(p, start, end, show, showComputers);
1006     return COM_OK;
1007   } else {
1008     target = player_search(p, param[0].val.word);
1009     if (target == 0) {
1010       pprintf(p, "Target %s not found.\n", param[0].val.word);
1011       return COM_OK;
1012     }
1013     connected = (target > 0);
1014     if (!connected)
1015       target = -target - 1;
1016     else
1017       target--;
1018
1019     if (param[1].type != TYPE_NULL)
1020       show = ShowFromString(param[1].val.word);
1021     DisplayTargetRank(p, player_globals.parray[target].name, show, showComputers);
1022     if (!connected)
1023       player_remove(target);
1024     return COM_OK;
1025   }
1026 }
1027
1028 /* CompareStats returns 1 if s1 comes first, -1 if s2 comes first, and 0
1029    if neither takes precedence. */
1030 #if 0
1031 static int CompareStats(char *name1, statistics *s1,
1032                           char *name2, statistics *s2)
1033 {
1034   int i, l1;
1035
1036   if (s1 == NULL)
1037     if (s2 == NULL)
1038       return 0;
1039     else
1040       return -1;
1041   else if (s2 == NULL)
1042     return 1;
1043
1044   if (s1->rating > s2->rating)
1045     return 1;
1046   if (s1->rating < s2->rating)
1047     return -1;
1048   l1 = strlen(name1);
1049   for (i = 0; i < l1; i++) {
1050     if (name2[i] == '\0')
1051       return -1;
1052     if (tolower(name1[i]) < tolower(name2[i]))
1053       return 1;
1054     if (tolower(name1[i]) > tolower(name2[i]))
1055       return -1;
1056   }
1057   if (name2[i] != '\0')
1058     return 1;
1059 /*  if (s1->sterr < s2->sterr) return 1;
1060   if (s1->sterr > s2->sterr) return -1;
1061   if (s1->num > s2->num) return 1;
1062   if (s1->num < s2->num) return -1;
1063 */
1064   d_printf( "Duplicate entries found: %s.\n", name1);
1065   return 0;
1066 }
1067 #endif
1068 static int GetRankFileName(char *out, int type)
1069 {
1070   switch (type) {
1071     case TYPE_BLITZ:
1072         sprintf(out, "%s/rank.blitz", STATS_DIR);
1073         return type;
1074     case TYPE_STAND:
1075         sprintf(out, "%s/rank.std", STATS_DIR);
1076         return type;
1077     case TYPE_WILD:
1078         sprintf(out, "%s/rank.wild", STATS_DIR);
1079         return type;
1080     default:
1081         return -1;
1082   }
1083 }
1084
1085 /* loon: Turning this off 28 Oct 1995 (temporary:)) since we're lagged
1086    into outer space */
1087 void UpdateRank(int type, char *addName,
1088                 struct statistics *sNew, char *delName)
1089 {}
1090
1091 #if 0
1092 void UpdateRank(int type, char *addName,
1093                 struct statistics *sNew, char *delName)
1094 {
1095   char RankFile[MAX_FILENAME_SIZE];
1096   char TmpRankFile[MAX_FILENAME_SIZE];
1097   char line[MAX_RANK_LINE];
1098   char login[MAX_LOGIN_NAME];
1099
1100   int comp;
1101   statistics sCur;
1102   FILE *fp;
1103   FILE *fptemp;
1104
1105   if (GetRankFileName(RankFile, type) < 0)
1106     return;
1107   fp = fopen_s(RankFile, "r");
1108   if (fp == NULL) {
1109     d_printf( "Can't open rank file to update.\n");
1110     return;
1111   }
1112   sprintf(TmpRankFile, "%s/tmpRank", sdir);
1113   fptemp = fopen_s(TmpRankFile, "w");
1114   if (fptemp == NULL) {
1115     d_printf("Unable to open rank file for updating.\n");
1116     fclose (fp);
1117     return;
1118   }
1119   while (fgets(line, MAX_RANK_LINE - 1, fp)) {
1120     sscanf(line, "%s %d %d %d", login, &sCur.rating,
1121            &sCur.num, &comp);
1122     if (delName != NULL && !strcasecmp(delName, login)) {       /* Kill name. */
1123       delName = NULL;
1124       continue;
1125     }
1126     if (addName != NULL && CompareStats(addName, sNew, login, &sCur) > 0) {
1127       int computer = in_list(-1, L_COMPUTER, addName);
1128       fprintf(fptemp, "%s %d %d %d\n", addName, sNew->rating,
1129               sNew->num, computer);
1130       addName = NULL;
1131     }
1132     fprintf(fptemp, "%s %d %d %d\n", login, sCur.rating, sCur.num, comp);
1133   }
1134   fclose(fptemp);
1135   fclose(fp);
1136
1137   rename(TmpRankFile, RankFile);
1138 }
1139 #endif
1140
1141 static void DisplayRankHead(int p, int show)
1142 {
1143   char Line[MAX_STRING_LENGTH];
1144
1145   Line[0] = '\0';
1146   if (CheckFlag(show, SHOW_BLITZ))
1147     strcat(Line, "         Blitz          ");
1148   if (CheckFlag(show, SHOW_STANDARD))
1149     strcat(Line, "       Standard          ");
1150   if (CheckFlag(show, SHOW_WILD))
1151     strcat(Line, "          Wild");
1152   pprintf(p, "%s\n\n", Line);
1153 }
1154
1155 static int CountRankLine(int countComp, char *loginName,
1156                            int num, int is_computer)
1157 {
1158   if (loginName == NULL || loginName[0] == '\0')
1159     return 0;
1160   return (countComp || !is_computer) && (is_active(num));
1161 }
1162
1163 static int GetRank(FILE * fp, char *target, int countComp)
1164 {
1165   int count = 0;
1166   int nGames, is_computer;
1167   int playerFound = 0;
1168   char line[MAX_RANK_LINE];
1169   char login[MAX_LOGIN_NAME];
1170
1171   while (fgets(line, MAX_RANK_LINE - 1, fp) && !playerFound) {
1172     sscanf(line, "%s %*d %d %d", login, &nGames, &is_computer);
1173     if ((playerFound = !strcasecmp(login, target))
1174         || CountRankLine(countComp, login, nGames, is_computer))
1175       count++;
1176   }
1177   return (playerFound ? count : -1);
1178 }
1179
1180 static void PositionFilePtr(FILE * fp, int count, int *last,
1181                               int *nTied, int showComp)
1182 {
1183   int i, rating, nGames, is_computer;
1184   char login[MAX_LOGIN_NAME];
1185   char line[MAX_RANK_LINE];
1186
1187   if (fp == NULL)
1188     return;
1189   rewind(fp);
1190   for (i = 1; i < count; i++) {
1191     do {
1192       fgets(line, MAX_RANK_LINE - 1, fp);
1193       if (feof(fp))
1194         break;
1195       sscanf(line, "%s %d %d %d", login, &rating, &nGames, &is_computer);
1196     } while (!CountRankLine(showComp, login, nGames, is_computer));
1197     if (rating != *last) {
1198       *nTied = 1;
1199       *last = rating;
1200     } else
1201       (*nTied)++;
1202   }
1203 }
1204
1205 static int ShowRankEntry(int p, FILE * fp, int count, int comp,
1206                            char *target, int *lastRating, int *nTied)
1207 {
1208   char newLine[MAX_RANK_LINE];
1209   char login[MAX_LOGIN_NAME];
1210   int rating, findable, nGames, is_comp;
1211
1212   findable = (count > 0) && !feof(fp);
1213   if (findable) {
1214     do {
1215       fgets(newLine, MAX_RANK_LINE - 1, fp);
1216       if (feof(fp))
1217         findable = 0;
1218       else if (newLine[0] != '\0')
1219         sscanf(newLine, "%s %d %d %d",
1220                login, &rating, &nGames, &is_comp);
1221       else
1222         login[0] = '\0';
1223     } while (!CountRankLine(comp, login, nGames, is_comp) && findable
1224              && strcasecmp(login, target));
1225   }
1226   if (findable) {
1227     if (!strcasecmp(login, target)
1228         && !CountRankLine(comp, login, nGames, is_comp)) {
1229       pprintf_highlight(p, "----  %-12.12s %4s", login, ratstr(rating));
1230       pprintf(p, "  ");
1231       return 0;
1232     } else if (*lastRating == rating && *nTied < 1) {
1233       pprintf(p, "      ");
1234       if (!strcasecmp(login, target))
1235         pprintf_highlight(p, "%-12.12s %4s", login, ratstr(rating));
1236       else
1237         pprintf(p, "%-12.12s %4s", login, ratstr(rating));
1238       pprintf(p, "  ");
1239       return 1;
1240     } else {
1241       if (*nTied >= 1) {
1242         if (*lastRating == rating)
1243           count -= *nTied;
1244         *nTied = -1;
1245       }
1246       if (!strcasecmp(login, target))
1247         pprintf_highlight(p, "%4d. %-12.12s %4s",
1248                           count, login, ratstr(rating));
1249       else
1250         pprintf(p, "%4d. %-12.12s %4s",
1251                 count, login, ratstr(rating));
1252       pprintf(p, "  ");
1253       *lastRating = rating;
1254       return 1;
1255     }
1256   } else {
1257     pprintf(p, "%25s", "");
1258     return 1;
1259   }
1260 }
1261
1262 static int CountAbove(int num, int blitz, int std, int wild, int which)
1263 {
1264   int max = blitz;
1265
1266   if (max < std)
1267     max = std;
1268   if (max < wild)
1269     max = wild;
1270   return (max <= (num + 1) / 2 ? max - 1 : (num + 1) / 2);
1271 }
1272
1273 static int ShowRankLines(int p, FILE * fb, FILE * fs, FILE * fw, int bCount,
1274         int sCount, int wCount, int n, int showComp, int show, char *target)
1275 {
1276   int lastBlitz = 9999, nTiedBlitz = 0;
1277   int lastStd = 9999, nTiedStd = 0;
1278   int lastWild = 9999, nTiedWild = 0;
1279   int i;
1280
1281   if (n <= 0)
1282     return 0;
1283   if (CheckFlag(show, SHOW_BLITZ)) {
1284     PositionFilePtr(fb, bCount, &lastBlitz, &nTiedBlitz, showComp);
1285     if (feof(fb))
1286       FlagOFF(show, SHOW_BLITZ);
1287   }
1288   if (CheckFlag(show, SHOW_STANDARD)) {
1289     PositionFilePtr(fs, sCount, &lastStd, &nTiedStd, showComp);
1290     if (feof(fs))
1291       FlagOFF(show, SHOW_STANDARD);
1292   }
1293   if (CheckFlag(show, SHOW_WILD)) {
1294     PositionFilePtr(fw, wCount, &lastWild, &nTiedWild, showComp);
1295     if (feof(fw))
1296       FlagOFF(show, SHOW_WILD);
1297   }
1298   if (!CheckFlag(show, SHOW_BLITZ | SHOW_STANDARD | SHOW_WILD))
1299     return 0;
1300   DisplayRankHead(p, show);
1301
1302   for (i = 0; i < n && show; i++) {
1303     if (CheckFlag(show, SHOW_BLITZ))
1304       bCount += ShowRankEntry(p, fb, bCount, showComp, target,
1305                               &lastBlitz, &nTiedBlitz);
1306     if (CheckFlag(show, SHOW_STANDARD))
1307       sCount += ShowRankEntry(p, fs, sCount, showComp, target,
1308                               &lastStd, &nTiedStd);
1309     if (CheckFlag(show, SHOW_WILD))
1310       wCount += ShowRankEntry(p, fw, wCount, showComp, target,
1311                               &lastWild, &nTiedWild);
1312     pprintf(p, "\n");
1313   }
1314   return 1;
1315 }
1316
1317 static int DisplayTargetRank(int p, char *target, int show, int showComp)
1318 {
1319   int numToShow = 20;
1320   int blitzRank = -1, blitzCount;
1321   int stdRank = -1, stdCount;
1322   int wildRank = -1, wildCount;
1323   int numAbove;
1324   char Path[MAX_FILENAME_SIZE];
1325   FILE *fb = NULL, *fs = NULL, *fw = NULL;
1326
1327   if (CheckFlag(show, SHOW_BLITZ)) {
1328     GetRankFileName(Path, TYPE_BLITZ);
1329     fb = (FILE *) fopen_s(Path, "r");
1330     if (fb != NULL)
1331       blitzRank = GetRank(fb, target, showComp);
1332     if (blitzRank < 0)
1333       FlagOFF(show, SHOW_BLITZ);
1334   }
1335   if (CheckFlag(show, SHOW_STANDARD)) {
1336     GetRankFileName(Path, TYPE_STAND);
1337     fs = (FILE *) fopen_s(Path, "r");
1338     if (fs != NULL)
1339       stdRank = GetRank(fs, target, showComp);
1340     if (stdRank < 0)
1341       FlagOFF(show, SHOW_STANDARD);
1342   }
1343   if (CheckFlag(show, SHOW_WILD)) {
1344     GetRankFileName(Path, TYPE_WILD);
1345     if (CheckFlag(show, SHOW_WILD))
1346       fw = (FILE *) fopen_s(Path, "r");
1347     if (fw != NULL)
1348       wildRank = GetRank(fw, target, showComp);
1349     if (wildRank < 0)
1350       FlagOFF(show, SHOW_WILD);
1351   }
1352   if (!CheckFlag(show, SHOW_BLITZ | SHOW_STANDARD | SHOW_WILD)) {
1353     pprintf(p, "No ratings to show.\n");
1354     if (fb != NULL) fclose(fb);
1355     if (fs != NULL) fclose(fs);
1356     if (fw != NULL) fclose(fw);
1357     return (0);
1358   }
1359   numAbove = CountAbove(numToShow, blitzRank, stdRank, wildRank, show);
1360   blitzCount = blitzRank - numAbove;
1361   stdCount = stdRank - numAbove;
1362   wildCount = wildRank - numAbove;
1363
1364   ShowRankLines(p, fb, fs, fw, blitzCount, stdCount, wildCount,
1365                 numToShow, showComp, show, target);
1366   if (fb != NULL) fclose(fb);
1367   if (fs != NULL) fclose(fs);
1368   if (fw != NULL) fclose(fw);
1369   return (1);
1370 }
1371
1372 static int DisplayRankedPlayers(int p, int start, int end,
1373                                  int show, int showComp)
1374 {
1375   int num = end - start + 1;
1376   FILE *fb = NULL, *fs = NULL, *fw = NULL;
1377   char Path[MAX_FILENAME_SIZE];
1378
1379   if (start <= 0)
1380     start = 1;
1381   if (num <= 0)
1382     return 0;
1383   if (num > 100)
1384     num = 100;
1385   if (CheckFlag(show, SHOW_BLITZ)) {
1386     GetRankFileName(Path, TYPE_BLITZ);
1387     fb = (FILE *) fopen_s(Path, "r");
1388     if (fb == NULL)
1389       FlagOFF(show, SHOW_BLITZ);
1390   }
1391   if (CheckFlag(show, SHOW_STANDARD)) {
1392     GetRankFileName(Path, TYPE_STAND);
1393     fs = (FILE *) fopen_s(Path, "r");
1394     if (fs == NULL)
1395       FlagOFF(show, SHOW_STANDARD);
1396   }
1397   if (CheckFlag(show, SHOW_WILD)) {
1398     GetRankFileName(Path, TYPE_WILD);
1399     fw = (FILE *) fopen_s(Path, "r");
1400     if (fw == NULL)
1401       FlagOFF(show, SHOW_WILD);
1402   }
1403   ShowRankLines(p, fb, fs, fw, start, start, start,
1404                 num, showComp, show, "");
1405   if (fb)
1406     fclose(fb);
1407   if (fs)
1408     fclose(fs);
1409   if (fw)
1410     fclose(fw);
1411   return 1;
1412 }
1413
1414 static int ShowFromString(char *s)
1415 {
1416   int i, len = strlen(s);
1417   int show = 0;
1418
1419   if (s == NULL || s[0] == '\0')
1420     return SHOW_BLITZ | SHOW_STANDARD | SHOW_WILD;
1421   for (i = 0; i < len; i++) {
1422     switch (s[i]) {
1423     case 'b':
1424       FlagON(show, SHOW_BLITZ);
1425       break;
1426     case 's':
1427       FlagON(show, SHOW_STANDARD);
1428       break;
1429     case 'w':
1430       FlagON(show, SHOW_WILD);
1431       break;
1432     }
1433   }
1434   return (show);
1435 }
1436
1437 static int Best(int p, param_list param, int ShowComp)
1438 {
1439   int show = SHOW_BLITZ | SHOW_STANDARD | SHOW_WILD;
1440
1441   if (param[0].type != TYPE_NULL)
1442     show = ShowFromString(param[0].val.word);
1443
1444   DisplayRankedPlayers(p, 1, 20, show, ShowComp);
1445   return COM_OK;
1446 }
1447