[BACK]Return to cards.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / games / cribbage

Annotation of src/games/cribbage/cards.c, Revision 1.7

1.7     ! agc         1: /*     $NetBSD: cards.c,v 1.6 1999/09/30 18:01:32 jsm Exp $    */
1.3       cgd         2:
                      3: /*-
                      4:  * Copyright (c) 1980, 1993
                      5:  *     The Regents of the University of California.  All rights reserved.
1.1       cgd         6:  *
                      7:  * Redistribution and use in source and binary forms, with or without
                      8:  * modification, are permitted provided that the following conditions
                      9:  * are met:
                     10:  * 1. Redistributions of source code must retain the above copyright
                     11:  *    notice, this list of conditions and the following disclaimer.
                     12:  * 2. Redistributions in binary form must reproduce the above copyright
                     13:  *    notice, this list of conditions and the following disclaimer in the
                     14:  *    documentation and/or other materials provided with the distribution.
1.7     ! agc        15:  * 3. Neither the name of the University nor the names of its contributors
1.1       cgd        16:  *    may be used to endorse or promote products derived from this software
                     17:  *    without specific prior written permission.
                     18:  *
                     19:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
                     20:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     21:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     22:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
                     23:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     24:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     25:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     26:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     27:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     28:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     29:  * SUCH DAMAGE.
                     30:  */
                     31:
1.4       lukem      32: #include <sys/cdefs.h>
1.1       cgd        33: #ifndef lint
1.4       lukem      34: #if 0
1.3       cgd        35: static char sccsid[] = "@(#)cards.c    8.1 (Berkeley) 5/31/93";
1.4       lukem      36: #else
1.7     ! agc        37: __RCSID("$NetBSD: cards.c,v 1.6 1999/09/30 18:01:32 jsm Exp $");
1.4       lukem      38: #endif
1.1       cgd        39: #endif /* not lint */
                     40:
1.3       cgd        41: #include <curses.h>
                     42: #include <stdio.h>
                     43: #include <stdlib.h>
                     44: #include <time.h>
                     45:
                     46: #include "deck.h"
                     47: #include "cribbage.h"
1.1       cgd        48:
                     49:
                     50: /*
1.3       cgd        51:  * Initialize a deck of cards to contain one of each type.
1.1       cgd        52:  */
1.3       cgd        53: void
                     54: makedeck(d)
                     55:        CARD    d[];
1.1       cgd        56: {
1.4       lukem      57:        int i, j, k;
1.1       cgd        58:
1.3       cgd        59:        i = time(NULL);
                     60:        i = ((i & 0xff) << 8) | ((i >> 8) & 0xff) | 1;
                     61:        srand(i);
1.1       cgd        62:        k = 0;
1.3       cgd        63:        for (i = 0; i < RANKS; i++)
                     64:                for (j = 0; j < SUITS; j++) {
                     65:                        d[k].suit = j;
                     66:                        d[k++].rank = i;
                     67:                }
1.1       cgd        68: }
                     69:
                     70: /*
1.3       cgd        71:  * Given a deck of cards, shuffle it -- i.e. randomize it
                     72:  * see Knuth, vol. 2, page 125.
1.1       cgd        73:  */
1.3       cgd        74: void
                     75: shuffle(d)
                     76:        CARD d[];
                     77: {
1.4       lukem      78:        int j, k;
1.3       cgd        79:        CARD c;
                     80:
                     81:        for (j = CARDS; j > 0; --j) {
                     82:                k = (rand() >> 4) % j;          /* random 0 <= k < j */
                     83:                c = d[j - 1];                   /* exchange (j - 1) and k */
                     84:                d[j - 1] = d[k];
                     85:                d[k] = c;
1.1       cgd        86:        }
                     87: }
                     88:
                     89: /*
                     90:  * return true if the two cards are equal...
                     91:  */
1.3       cgd        92: int
                     93: eq(a, b)
                     94:        CARD a, b;
1.1       cgd        95: {
1.3       cgd        96:        return ((a.rank == b.rank) && (a.suit == b.suit));
1.1       cgd        97: }
                     98:
                     99: /*
1.6       jsm       100:  * is_one returns TRUE if a is in the set of cards b
1.1       cgd       101:  */
1.3       cgd       102: int
1.6       jsm       103: is_one(a, b, n)
1.5       jsm       104:        CARD a;
                    105:        const CARD b[];
1.3       cgd       106:        int n;
                    107: {
1.4       lukem     108:        int i;
1.3       cgd       109:
                    110:        for (i = 0; i < n; i++)
                    111:                if (eq(a, b[i]))
                    112:                        return (TRUE);
                    113:        return (FALSE);
1.1       cgd       114: }
                    115:
                    116: /*
                    117:  * remove the card a from the deck d of n cards
                    118:  */
1.3       cgd       119: void
                    120: cremove(a, d, n)
                    121:        CARD a, d[];
                    122:        int n;
                    123: {
1.4       lukem     124:        int i, j;
1.3       cgd       125:
                    126:        for (i = j = 0; i < n; i++)
                    127:                if (!eq(a, d[i]))
                    128:                        d[j++] = d[i];
                    129:        if (j < n)
                    130:                d[j].suit = d[j].rank = EMPTY;
1.1       cgd       131: }
                    132:
                    133: /*
                    134:  * sorthand:
                    135:  *     Sort a hand of n cards
                    136:  */
1.3       cgd       137: void
1.1       cgd       138: sorthand(h, n)
1.4       lukem     139:        CARD h[];
1.3       cgd       140:        int n;
1.1       cgd       141: {
1.4       lukem     142:        CARD *cp, *endp;
1.3       cgd       143:        CARD c;
1.1       cgd       144:
                    145:        for (endp = &h[n]; h < endp - 1; h++)
1.3       cgd       146:                for (cp = h + 1; cp < endp; cp++)
                    147:                        if ((cp->rank < h->rank) ||
                    148:                            (cp->rank == h->rank && cp->suit < h->suit)) {
                    149:                                c = *h;
                    150:                                *h = *cp;
                    151:                                *cp = c;
                    152:                        }
1.1       cgd       153: }

CVSweb <webmaster@jp.NetBSD.org>