Coupling Cribbage and Erlang into a program sounds like a fun little program to write to aid in learning Erlang while writing a program that brings a game I like in life to the virtual world. Is it the most efficient? Probably not, but you gotta start somewhere. To the code! The first thing I wanted to do was create a method to calculate points. An ace is a 1, 2-10 are face value, and Jack, Queen, King are 11, 12, 13, respectively. Easy adjustments could be made to allow characters (A, J, Q, K) but for now, I like keeping it simple.



    points([]) -> 0;
    points(L) ->
        Hand = lists:sort(L),
        fifteens(Hand, 0) + runs(Hand, 0, 0) + pairs(Hand, 1, 0).

The above creates a module called cribbage and exports a function called points/1 which takes one parameter, a list of cards. There are three kinds of scoring in Cribbage: combinations of cards that equal 15, runs of three or more, and pairs (or sets or four of a kind). There is one other kind, but it's not part of this portion of the game.

    cardval(C) when C > 9 -> 10;
    cardval(C) -> C.

    fifteens(_L, Total) when Total > 15 -> 0;
    fifteens(_Hand, Total) when Total =:= 15 -> 2;
    fifteens([], _Total) -> 0;
    fifteens([H | T], Total) when Total < 15 ->
        fifteens(T, Total) + fifteens(T, Total + cardval(H)).

cardval is a function that converts the value of face cards (11-J,12-Q,13-K) to 10 and leaves other cards unchanged in value. This is useful in finding all combinations of 15 in the hand. When a combo equals 15, two points are added to the score. Runs were the trickiest of the three to get right. First, I defined a simple function to determine the points for a run of given length.

    run(3) -> 3;
    run(4) -> 6;
    run(5) -> 12;
    run(_Length) -> 0.

Some people may play with different values for runs of different lengths, so this allows for easy editing. Runs come in two flavors: 1) A normal run, and 2) A run where one or two of the cards are doubled. To account for this, I have runs/3 and runs/4. runs/3 handles the first case, and passes control to runs/4 when a run of the second case is encountered. Another special case is when a run has two different cards doubled (e.g. 3,4,4,5,5) where the run of three is doubled and doubled again.

    %% two cases for runs
    %%   1. A straight run - 4,5,6,7
    %%   2. A run with a double in the sequence - 4,4,5,6 or 4,5,5,6
    runs([], _Curr, Len) -> run(Len);
    runs([H | T], Curr, Len) when H =:= (Curr+1) -> runs(T, H, Len + 1);
    runs([H | T], Curr, Len) when H =:= Curr -> runs(T, Curr, Len, {H, 2});
    runs([H | T], _Curr, Len) -> run(Len) + runs(T, H, 1).

    runs([], _Curr, Len, {_Card, Mult}) -> Mult * run(Len);
    runs([H | T], Curr, Len, {Card, Mult}) when H =:= (Curr+1) ->
        runs(T, H, (Len+1), {Card, Mult});
    %% needed for special cases where multiple cards are doubled up
    %% like 3,4,4,5,5
    runs([H | T], Curr, Len, {Card, Mult}) when H =:= Curr, H > Card ->
        runs(T, Curr, Len, {H, (Mult*2)});
    %% handles a triple carding, like 2,2,2,3,4
    runs([H | T], Curr, Len, {Card, Mult}) when H =:= Curr ->
        runs(T, Curr, Len, {Card, (Mult+1)});
    runs([H | T], _Curr, Len, {_Card, Mult}) ->
        (Mult * run(Len)) + runs(T, H, 1).

For pairs, I do a similar thing: define a pair(Length) function that returns the point value given a number of similar cards. But it's all pretty straightforward.

    pairs([], Pairs, _Curr) -> pair(Pairs);
    pairs([H | T], Pairs, Curr) when H =:= Curr -> pairs(T, Pairs+1, Curr);
    pairs([H | T], Pairs, _Curr) -> pair(Pairs) + pairs(T, 1, H).

    pair(2) -> 2;
    pair(3) -> 6;
    pair(4) -> 12;
    pair(_Length) -> 0.

That's it for now. Actual game play to come. You can get the code here.