Return to cribbage.6 CVS log

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

Annotation of 43BSDReno/games/cribbage/cribbage.6, revision 1.1

1.1     ! root        1: .\" Copyright (c) 1980 Regents of the University of California.
        !             2: .\" All rights reserved.
        !             3: .\"
        !             4: .\" Redistribution and use in source and binary forms are permitted provided
        !             5: .\" that: (1) source distributions retain this entire copyright notice and
        !             6: .\" comment, and (2) distributions including binaries display the following
        !             7: .\" acknowledgement:  ``This product includes software developed by the
        !             8: .\" University of California, Berkeley and its contributors'' in the
        !             9: .\" documentation or other materials provided with the distribution and in
        !            10: .\" all advertising materials mentioning features or use of this software.
        !            11: .\" Neither the name of the University nor the names of its contributors may
        !            12: .\" be used to endorse or promote products derived from this software without
        !            13: .\" specific prior written permission.
        !            14: .\" THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
        !            15: .\" WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
        !            16: .\" MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
        !            17: .\"
        !            18: .\"    @(#)cribbage.6  6.5 (Berkeley) 6/23/90
        !            19: .\"
        !            20: .TH CRIBBAGE 6 "June 23, 1990"
        !            21: .UC 4
        !            22: .SH NAME
        !            23: cribbage \- the card game cribbage
        !            24: .SH SYNOPSIS
        !            25: .B /usr/games/cribbage
        !            26: [
        !            27: .B \-req
        !            28: ]
        !            29: .I name ...
        !            30: .SH DESCRIPTION
        !            31: .I Cribbage
        !            32: plays the card game cribbage, with the program playing one hand
        !            33: and the user the other.  The program will initially ask the user if
        !            34: the rules of the game are needed \- if so, it will print out
        !            35: the appropriate section from
        !            36: .I According to Hoyle
        !            37: with
        !            38: .I more (I).
        !            39: .PP
        !            40: .I Cribbage
        !            41: options include:
        !            42: .TP
        !            43: .B \-e
        !            44: When the player makes a mistake scoring his hand or crib, provide an
        !            45: explanation of the correct score.  (This is especially useful for
        !            46: beginning players.)
        !            47: .TP
        !            48: .B \-q
        !            49: Print a shorter form of all messages \- this is only recommended for
        !            50: users who have played the game without specifying this option.
        !            51: .TP
        !            52: .B \-r
        !            53: Instead of asking the player to cut the deck, the program will randomly
        !            54: cut the deck.
        !            55: .PP
        !            56: .I Cribbage
        !            57: first asks the player whether he wishes to play a short game
        !            58: (\*(lqonce around\*(rq, to 61) or a long game (\*(lqtwice around\*(rq, to 121).  A
        !            59: response of `s' will result in a short game, any other response will
        !            60: play a long game.
        !            61: .PP
        !            62: At the start of the first game, the program
        !            63: asks the player to cut the deck to determine who gets the
        !            64: first crib.  The user should respond with a number between 0 and
        !            65: 51, indicating how many cards down the deck is to be cut.  The player
        !            66: who cuts the lower ranked card gets the first crib.
        !            67: If more than one game is played, the
        !            68: loser of the previous game gets the first crib in the current game.
        !            69: .PP
        !            70: For each hand, the program first prints the player's hand,
        !            71: whose crib it is, and then asks the player
        !            72: to discard two cards into the crib.  The cards are prompted for
        !            73: one per line, and are typed as explained below.
        !            74: .PP
        !            75: After discarding, the program cuts the deck (if it is the player's
        !            76: crib) or asks the player to cut the deck (if it's its crib); in the latter
        !            77: case, the appropriate response is a number from 0 to 39 indicating
        !            78: how far down the remaining 40 cards are to be cut.
        !            79: .PP
        !            80: After cutting the deck, play starts with the non-dealer (the person
        !            81: who doesn't have the crib) leading the first card.
        !            82: Play continues, as per cribbage, until all cards are exhausted.  The
        !            83: program keeps track of the scoring of all points and the total of
        !            84: the cards on the table.
        !            85: .PP
        !            86: After play, the hands are scored.  The program requests the player to
        !            87: score his hand (and the crib, if it is his) by printing out the
        !            88: appropriate cards (and the cut card enclosed in brackets).
        !            89: Play continues until one player reaches the game limit (61 or 121).
        !            90: .PP
        !            91: A carriage return when a numeric input is expected is equivalent
        !            92: to typing the lowest legal value; when cutting the deck this
        !            93: is equivalent to choosing the top card.
        !            94: .PP
        !            95: Cards are specified as rank followed by suit.  The ranks may be specified
        !            96: as one of:
        !            97: `a', `2', `3', `4', `5', `6', `7', `8', `9', `t', `j', `q', and `k',
        !            98: or alternatively, one of: \*(lqace\*(rq, \*(lqtwo\*(rq, \*(lqthree\*(rq, \*(lqfour\*(rq, \*(lqfive\*(rq, \*(lqsix\*(rq,
        !            99: \*(lqseven\*(rq, \*(lqeight\*(rq, \*(lqnine\*(rq, \*(lqten\*(rq, \*(lqjack\*(rq, \*(lqqueen\*(rq, and \*(lqking\*(rq.
        !           100: Suits may be specified as: `s', `h', `d', and `c', or alternatively as:
        !           101: \*(lqspades\*(rq, \*(lqhearts\*(rq, \*(lqdiamonds\*(rq, and \*(lqclubs\*(rq.
        !           102: A card may be specified as: <rank> \*(lq \*(rq <suit>, or: <rank> \*(lq of \*(rq <suit>.
        !           103: If the single letter rank and suit designations are used, the space
        !           104: separating the suit and rank may be left out.  Also, if only one card
        !           105: of the desired rank is playable, typing the rank is sufficient.
        !           106: For example, if your hand was \*(lq2H, 4D, 5C, 6H, JC, KD\*(rq and it was
        !           107: desired to discard the king of diamonds, any of the following could be typed:
        !           108: \*(lqk\*(rq, \*(lqking\*(rq, \*(lqkd\*(rq, \*(lqk d\*(rq, \*(lqk of d\*(rq, \*(lqking d\*(rq, \*(lqking of d\*(rq, \*(lqk diamonds\*(rq,
        !           109: \*(lqk of diamonds\*(rq, \*(lqking diamonds\*(rq, or \*(lqking of diamonds\*(rq.
        !           110: .SH FILES
        !           111: .ta 2i
        !           112: /usr/games/cribbage
        !           113: .SH AUTHORS
        !           114: Earl T. Cohen wrote the logic.
        !           115: Ken Arnold added the screen oriented interface.

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