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.

-module(cribbage).
-export([points/1]).
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.