Annotation of 43BSDReno/games/cribbage/cribbage.6, revision 1.1.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.

unix.superglobalmegacorp.com

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