Return to score.c CVS log

Up to [CSRG BSD Unix] / 43BSD / games / cribbage

Annotation of 43BSD/games/cribbage/score.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1980 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  */
        !             6: 
        !             7: #ifndef lint
        !             8: static char sccsid[] = "@(#)score.c    5.1 (Berkeley) 5/30/85";
        !             9: #endif not lint
        !            10: 
        !            11: #include       <stdio.h>
        !            12: #include       "deck.h"
        !            13: #include       "cribbage.h"
        !            14: 
        !            15: 
        !            16: /*
        !            17:  * the following arrays give the sum of the scores of the (50 2)*48 = 58800
        !            18:  * hands obtainable for the crib given the two cards whose ranks index the
        !            19:  * array.  the two arrays are for the case where the suits are equal and
        !            20:  * not equal respectively
        !            21:  */
        !            22: 
        !            23: long           crbescr[ 169 ]          = {
        !            24:     -10000, 271827, 278883, 332319, 347769, 261129, 250653, 253203, 248259,
        !            25:     243435, 256275, 237435, 231051, -10000, -10000, 412815, 295707, 349497,
        !            26:     267519, 262521, 259695, 254019, 250047, 262887, 244047, 237663, -10000,
        !            27:     -10000, -10000, 333987, 388629, 262017, 266787, 262971, 252729, 254475,
        !            28:     267315, 248475, 242091, -10000, -10000, -10000, -10000, 422097, 302787,
        !            29:     256437, 263751, 257883, 254271, 267111, 248271, 241887, -10000, -10000,
        !            30:     -10000, -10000, -10000, 427677, 387837, 349173, 347985, 423861, 436701,
        !            31:     417861, 411477, -10000, -10000, -10000, -10000, -10000, -10000, 336387,
        !            32:     298851, 338667, 236487, 249327, 230487, 224103, -10000, -10000, -10000,
        !            33:     -10000, -10000, -10000, -10000, 408483, 266691, 229803, 246195, 227355,
        !            34:     220971, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000,
        !            35:     300675, 263787, 241695, 226407, 220023, -10000, -10000, -10000, -10000,
        !            36:     -10000, -10000, -10000, -10000, -10000, 295635, 273543, 219771, 216939,
        !            37:     -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000,
        !            38:     -10000, 306519, 252747, 211431, -10000, -10000, -10000, -10000, -10000,
        !            39:     -10000, -10000, -10000, -10000, -10000, -10000, 304287, 262971, -10000,
        !            40:     -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000,
        !            41:     -10000, -10000, 244131, -10000, -10000, -10000, -10000, -10000, -10000,
        !            42:     -10000, -10000, -10000, -10000, -10000, -10000, -10000  };
        !            43: 
        !            44: long           crbnescr[ 169 ]         = {
        !            45:     325272, 260772, 267828, 321264, 336714, 250074, 239598, 242148, 237204,
        !            46:     232380, 246348, 226380, 219996, -10000, 342528, 401760, 284652, 338442,
        !            47:     256464, 251466, 248640, 242964, 238992, 252960, 232992, 226608, -10000,
        !            48:     -10000, 362280, 322932, 377574, 250962, 255732, 251916, 241674, 243420,
        !            49:     257388, 237420, 231036, -10000, -10000, -10000, 360768, 411042, 291732,
        !            50:     245382, 252696, 246828, 243216, 257184, 237216, 230832, -10000, -10000,
        !            51:     -10000, -10000, 528768, 416622, 376782, 338118, 336930, 412806, 426774,
        !            52:     406806, 400422, -10000, -10000, -10000, -10000, -10000, 369864, 325332,
        !            53:     287796, 327612, 225432, 239400, 219432, 213048, -10000, -10000, -10000,
        !            54:     -10000, -10000, -10000, 359160, 397428, 255636, 218748, 236268, 216300,
        !            55:     209916, -10000, -10000, -10000, -10000, -10000, -10000, -10000, 331320,
        !            56:     289620, 252732, 231768, 215352, 208968, -10000, -10000, -10000, -10000,
        !            57:     -10000, -10000, -10000, -10000, 325152, 284580, 263616, 208716, 205884,
        !            58:     -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000,
        !            59:     321240, 296592, 241692, 200376, -10000, -10000, -10000, -10000, -10000,
        !            60:     -10000, -10000, -10000, -10000, -10000, 348600, 294360, 253044, -10000,
        !            61:     -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000,
        !            62:     -10000, 308664, 233076, -10000, -10000, -10000, -10000, -10000, -10000,
        !            63:     -10000, -10000, -10000, -10000, -10000, -10000, 295896  };
        !            64: 
        !            65: 
        !            66: static  int            ichoose2[ 5 ]           = { 0, 0, 2, 6, 12 };
        !            67: static  int            pairpoints, runpoints;  /* globals from pairuns */
        !            68: 
        !            69: 
        !            70: /*
        !            71:  * scorehand:
        !            72:  *     Score the given hand of n cards and the starter card.
        !            73:  *     n must be <= 4
        !            74:  */
        !            75: scorehand(hand, starter, n, crb, do_explain)
        !            76: register CARD          hand[];
        !            77: CARD                   starter;
        !            78: int                    n;
        !            79: BOOLEAN                        crb;            /* true if scoring crib */
        !            80: BOOLEAN                        do_explain;     /* true if must explain this hand */
        !            81: {
        !            82:        CARD                    h[(CINHAND + 1)];
        !            83:        register int            i, k;
        !            84:        register int            score;
        !            85:        register BOOLEAN        flag;
        !            86:        char                    buf[32];
        !            87: 
        !            88:        expl[0] = NULL;         /* initialize explanation */
        !            89:        score = 0;
        !            90:        flag = TRUE;
        !            91:        k = hand[0].suit;
        !            92:        for (i = 0; i < n; i++) {                       /* check for flush */
        !            93:            flag = (flag && (hand[i].suit == k));
        !            94:            if (hand[i].rank == JACK)                   /* check for his nibs */
        !            95:                if (hand[i].suit == starter.suit) {
        !            96:                    score++;
        !            97:                    if (do_explain)
        !            98:                        strcat(expl, "His Nobs");
        !            99:                }
        !           100:            h[i] = hand[i];
        !           101:        }
        !           102: 
        !           103:        if (flag && n >= CINHAND) {
        !           104:            if (do_explain && expl[0] != NULL)
        !           105:                strcat(expl, ", ");
        !           106:            if (starter.suit == k) {
        !           107:                score += 5;
        !           108:                if (do_explain)
        !           109:                    strcat(expl, "Five-flush");
        !           110:            }
        !           111:            else if (!crb) {
        !           112:                score += 4;
        !           113:                if (do_explain && expl[0] != NULL)
        !           114:                    strcat(expl, ", Four-flush");
        !           115:                else
        !           116:                    strcpy(expl, "Four-flush");
        !           117:            }
        !           118:        }
        !           119: 
        !           120:        if (do_explain && expl[0] != NULL)
        !           121:            strcat(expl, ", ");
        !           122:        h[n] = starter;
        !           123:        sorthand(h, n + 1);                     /* sort by rank */
        !           124:        i = 2 * fifteens(h, n + 1);
        !           125:        score += i;
        !           126:        if (do_explain)
        !           127:            if (i > 0) {
        !           128:                sprintf(buf, "%d points in fifteens", i);
        !           129:                strcat(expl, buf);
        !           130:            }
        !           131:            else
        !           132:                strcat(expl, "No fifteens");
        !           133:        i = pairuns(h, n + 1);
        !           134:        score += i;
        !           135:        if (do_explain)
        !           136:            if (i > 0) {
        !           137:                sprintf(buf, ", %d points in pairs, %d in runs", pairpoints,
        !           138:                    runpoints);
        !           139:                strcat(expl, buf);
        !           140:            }
        !           141:            else
        !           142:                strcat(expl, ", No pairs/runs");
        !           143:        return score;
        !           144: }
        !           145: 
        !           146: /*
        !           147:  * fifteens:
        !           148:  *     Return number of fifteens in hand of n cards
        !           149:  */
        !           150: fifteens(hand, n)
        !           151: register CARD          hand[];
        !           152: int                    n;
        !           153: {
        !           154:        register int            *sp, *np;
        !           155:        register int            i;
        !           156:        register CARD           *endp;
        !           157:        static int              sums[15], nsums[15];
        !           158: 
        !           159:        np = nsums;
        !           160:        sp = sums;
        !           161:        i = 16;
        !           162:        while (--i) {
        !           163:            *np++ = 0;
        !           164:            *sp++ = 0;
        !           165:        }
        !           166:        for (endp = &hand[n]; hand < endp; hand++) {
        !           167:            i = hand->rank + 1;
        !           168:            if (i > 10)
        !           169:                i = 10;
        !           170:            np = &nsums[i];
        !           171:            np[-1]++;                   /* one way to make this */
        !           172:            sp = sums;
        !           173:            while (i < 15) {
        !           174:                *np++ += *sp++;
        !           175:                i++;
        !           176:            }
        !           177:            sp = sums;
        !           178:            np = nsums;
        !           179:            i = 16;
        !           180:            while (--i)
        !           181:                *sp++ = *np++;
        !           182:        }
        !           183:        return sums[14];
        !           184: }
        !           185: 
        !           186: 
        !           187: 
        !           188: /*
        !           189:  * pairuns returns the number of points in the n card sorted hand
        !           190:  * due to pairs and runs
        !           191:  * this routine only works if n is strictly less than 6
        !           192:  * sets the globals pairpoints and runpoints appropriately
        !           193:  */
        !           194: 
        !           195: pairuns( h, n )
        !           196: 
        !           197:     CARD               h[];
        !           198:     int                        n;
        !           199: {
        !           200:        register  int           i;
        !           201:        int                     runlength, runmult, lastmult, curmult;
        !           202:        int                     mult1, mult2, pair1, pair2;
        !           203:        BOOLEAN                 run;
        !           204: 
        !           205:        run = TRUE;
        !           206:        runlength = 1;
        !           207:        mult1 = 1;
        !           208:        pair1 = -1;
        !           209:        mult2 = 1;
        !           210:        pair2 = -1;
        !           211:        curmult = runmult = 1;
        !           212:        for( i = 1; i < n; i++ )  {
        !           213:            lastmult = curmult;
        !           214:            if(  h[i].rank == h[i - 1].rank  )  {
        !           215:                if(  pair1 < 0  )  {
        !           216:                    pair1 = h[i].rank;
        !           217:                    mult1 = curmult = 2;
        !           218:                }
        !           219:                else  {
        !           220:                    if(  h[i].rank == pair1  )  {
        !           221:                        curmult = ++mult1;
        !           222:                    }
        !           223:                    else  {
        !           224:                        if(  pair2 < 0  )  {
        !           225:                            pair2 = h[i].rank;
        !           226:                            mult2 = curmult = 2;
        !           227:                        }
        !           228:                        else  {
        !           229:                            curmult = ++mult2;
        !           230:                        }
        !           231:                    }
        !           232:                }
        !           233:                if(  i == (n - 1)  &&  run  )  {
        !           234:                    runmult *= curmult;
        !           235:                }
        !           236:            }
        !           237:            else  {
        !           238:                curmult = 1;
        !           239:                if(  h[i].rank == h[i - 1].rank + 1  )  {
        !           240:                    if( run )  {
        !           241:                        ++runlength;
        !           242:                    }
        !           243:                    else  {
        !           244:                        if(  runlength < 3  )  {        /* only if old short */
        !           245:                            run = TRUE;
        !           246:                            runlength = 2;
        !           247:                            runmult = 1;
        !           248:                        }
        !           249:                    }
        !           250:                    runmult *= lastmult;
        !           251:                }
        !           252:                else  {
        !           253:                    if( run )  runmult *= lastmult;     /* if just ended */
        !           254:                    run = FALSE;
        !           255:                }
        !           256:            }
        !           257:        }
        !           258:        pairpoints = ichoose2[ mult1 ] + ichoose2[ mult2 ];
        !           259:        runpoints = ( runlength >= 3 ? runlength*runmult : 0 );
        !           260:        return(  pairpoints + runpoints  );
        !           261: }
        !           262: 
        !           263: 
        !           264: 
        !           265: /*
        !           266:  * pegscore tells how many points crd would get if played after
        !           267:  * the n cards in tbl during pegging
        !           268:  */
        !           269: 
        !           270: pegscore( crd, tbl, n, sum )
        !           271: 
        !           272:     CARD               crd,  tbl[];
        !           273:     int                        n;
        !           274:     int                        sum;
        !           275: {
        !           276:        BOOLEAN                 got[ RANKS ];
        !           277:        register  int           i, j, scr;
        !           278:        int                     k, lo, hi;
        !           279: 
        !           280:        sum += VAL( crd.rank );
        !           281:        if(  sum > 31  )  return( -1 );
        !           282:        if(  sum == 31  ||  sum == 15  )  scr = 2;
        !           283:        else                              scr = 0;
        !           284:        if(  !n  )  return( scr );
        !           285:        j = 1;
        !           286:        while(  ( crd.rank == tbl[n - j].rank )  &&  ( n - j >= 0 )  )  ++j;
        !           287:        if( j > 1 )  return( scr + ichoose2[j] );
        !           288:        if( n < 2 )  return( scr );
        !           289:        lo = hi = crd.rank;
        !           290:        for( i = 0; i < RANKS; i++ )  got[i] = FALSE;
        !           291:        got[ crd.rank ] = TRUE;
        !           292:        k = -1;
        !           293:        for( i = n - 1; i >= 0; --i )  {
        !           294:            if(  got[ tbl[i].rank ]  )  break;
        !           295:            got[ tbl[i].rank ] = TRUE;
        !           296:            if(  tbl[i].rank < lo  )  lo = tbl[i].rank;
        !           297:            if(  tbl[i].rank > hi  )  hi = tbl[i].rank;
        !           298:            for( j = lo; j <= hi; j++ )  if( !got[j] )  break;
        !           299:            if(  j > hi )  k = hi - lo + 1;
        !           300:        }
        !           301:        if(  k >= 3  )  return( scr + k );
        !           302:        else            return( scr );
        !           303: }
        !           304: 
        !           305: 
        !           306: 
        !           307: /*
        !           308:  * adjust takes a two card hand that will be put in the crib
        !           309:  * and returns an adjusted normalized score for the number of
        !           310:  * points such a crib will get.
        !           311:  */
        !           312: 
        !           313: adjust( cb, tnv )
        !           314: 
        !           315:     CARD               cb[], tnv;
        !           316: {
        !           317:        int                     i,  c0,  c1;
        !           318:        long                    scr;
        !           319: 
        !           320:        c0 = cb[0].rank;
        !           321:        c1 = cb[1].rank;
        !           322:        if(  c0 > c1  )  {
        !           323:            i = c0;
        !           324:            c0 = c1;
        !           325:            c1 = i;
        !           326:        }
        !           327:        if(  cb[0].suit != cb[1].suit  )  scr = crbnescr[ RANKS*c0 + c1 ];
        !           328:        else                              scr = crbescr[ RANKS*c0 + c1 ];
        !           329:        if(  scr <= 0  )  {
        !           330:            printf( "\nADJUST: internal error %d %d\n",  c0, c1 );
        !           331:            exit( 93 );
        !           332:        }
        !           333:        return(  (scr + 29400)/58800  );
        !           334: }
        !           335: 
        !           336: 
        !           337: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.