PROGRAM blackjack;

TYPE
baraja = array [1..52] of integer;

PROCEDURE LimpiarBaraja(var mazo:baraja);

(* Procedimiento que asigna el valor 0 a los elementos del array mazo*)
VAR
i: integer;
BEGIN
for i:= 1 to 52 do
mazo := 0
END;

PROCEDURE LimpiarMano(var mano: array of integer);

(* Procedimiento que asigna el valor 0 a los elementos del array mano*)
VAR
i: integer;
BEGIN
for i:= 1 to Length(mano) do
mano := 0
END;

FUNCTION SumaManoJ(mano: array of integer):integer;

(* Función que devuelve el valor sumado de las cartas de la mano del Jugador *)
VAR
i: integer;
BEGIN
SumaManoJ := 0;
writeln('manoLength: ', Length(mano));
(* Muestro la longitud del array para comprobarla *)
for i:= 1 to Length(mano) do
begin
writeln('mano[',i,']: ',mano);
(* Muestro los valores de las cartas de la mano para comprobarlos *)
SumaManoJ := SumaManoJ + mano
end;
END;

FUNCTION SumaManoC(mano: array of integer):integer;

(* Función que devuelve el valor sumado de las cartas de la mano del Casino *)
VAR
i: integer;
BEGIN
SumaManoC := 0;
writeln('manoLength: ', Length(mano));
for i:= 1 to Length(mano) do
begin
writeln('mano[',i,']: ',mano);
SumaManoC := SumaManoC + mano
end;
END;

PROCEDURE MostrarMazo(mazo:baraja);
(* Procedimiento realizado para testeo. Muestra el mazo *)
VAR
i: integer;
BEGIN
for i:= 1 to 52 do
writeln(mazo)
END;

PROCEDURE Barajar(var mazo:baraja);

(* Procedimiento que baraja el mazo *)
VAR
i, j, rndm : integer;
BEGIN
for i:=1 to 4 do
for j:= 1 to 13 do
begin
repeat
rndm := Random(53)
until (mazo[rndm] = 0);
if (j<10) then
mazo[rndm] := j
else
mazo[rndm] := 10
end;
END;

VAR
mazo : baraja;
partida, apuesta, balance, puntero, jugadaC, jugadaJ : integer;
manoJ: array[1..11] of integer;
manoC: array[1..10] of integer;

BEGIN
Randomize;
LimpiarBaraja(mazo);
LimpiarMano(manoJ);
LimpiarMano(manoC);
(* Inicializo a 0 el mazo y las manos del jugador y casino *)
Barajar(mazo);
partida := 1;
apuesta := 2;
balance := 0;
puntero := 1;
(* El puntero lo uso para indicar la carta siguiente a robar en el mazo *)
writeln('Partida: ',partida,'| Apuesta: ',apuesta,'| Balance: ',balance);
writeln('---------------------------------------------');
(* Partida, Apuesta y Balance son elementos que todavía no uso *)
manoJ[1] := mazo[puntero];
(* Se entrega una carta al jugador *)
puntero := puntero + 1;
manoJ[2] := mazo[puntero];
(* Se entrega una carta al jugador *)
puntero := puntero + 1;
manoC[1] := mazo[puntero];
(* Se entrega una carta al casino *)
puntero := puntero + 1;
jugadaJ := SumaManoJ(manoJ);
jugadaC := SumaManoC(manoC);
(* Asigno el valor de cada jugada llamando a la función SumaMano *)
writeln('Casino (',jugadaC,')');
writeln('Jugador (',jugadaJ,')')
(* Muestro el valor de las jugadas *)
END.

Digamos que lo que hago es barajar el mazo, repartir 2 cartas al jugador y una al casino, y
mostrar el valor de cada jugada. Es decir, que si al jugador le reparto un 4 y un 10, y al casino
un 7, el resultado tendría que ser:

Casino (7)
Jugador (14)

Sin embargo, por algún extraño motivo que se me escapa, no me funciona bien "la mano del
Casino", ya que la salida del programa cuando llamo a la función SumaManoC es:

manoLength: 10
mano[1]: 0
mano[2]: 0
mano[3]: 0
mano[4]: 0
mano[5]: 0
mano[6]: 0
mano[7]: 0
mano[8]: 0
mano[9]: 0
mano[10]: -27516

Es decir, que el elemento 1, la carta que le he repartido, no me la "lee", y el elemento último

tiene un valor obsceno y sin sentido. La jugada, por tanto, es la siguiente:

Casino (-27516)

La cosa es que si a la función SumaManoC, en vez de pasar el array como valor, lo paso como
variable, el elemento décimo ya toma el valor 0, pero el primer elemento también sigue
tomándolo (cuando si muestro su valor desde el código principal, sí lo muestra correctamente):

FUNCTION SumaManoC(var mano: array of integer):integer;

manoLength: 10
mano[1]: 0
mano[2]: 0
mano[3]: 0
mano[4]: 0
mano[5]: 0
mano[6]: 0
mano[7]: 0
mano[8]: 0
mano[9]: 0
mano[10]: 0

Casino (0)

PROCEDURE LimpiarMano(var mano: array of integer);

(* Procedimiento que asigna el valor 0 a los elementos del array mano*)
VAR
i: integer;
BEGIN
for i:= 1 to HIGH(mano) do
mano := 0
END;
uses crt,dos;
var Carta,Palo,Acum,col,Acum1,puntos,I:integer;
Opc:char;
{procedures}
procedure cartelteaspasado;
begin
textcolor(14);
gotoxy(40,5); writeln('--------------------------');
gotoxy(40,6); writeln('| TE PASASTE |');
gotoxy(40,7); writeln('| |');
gotoxy(40,8); writeln('| LO SENTIMOS! |');
gotoxy(40,9); writeln('| |');
gotoxy(40,10);writeln('--------------------------');
readln
end;
procedure cartelblackjack;
begin
textcolor(14);
gotoxy(40,5); writeln('--------------------------');
gotoxy(40,6); writeln('| BLACKJACK |');
gotoxy(40,7); writeln('| |');
gotoxy(40,8); writeln('| FELICIDADES! |');
gotoxy(40,9); writeln('| |');
gotoxy(40,10);writeln('--------------------------');
end;
procedure cartel1(a:integer);
var acum:integer;
begin
textcolor(14);
gotoxy(40,5); writeln('--------------------------');
gotoxy(40,6); writeln('| LLEVAS ' ,a,' ');
gotoxy(40,7); writeln('| |');
gotoxy(40,8); writeln('| Pulsa P para Plantarte |');
gotoxy(40,9); writeln('| Pulsa INTRO para pedir |');
gotoxy(40,10);writeln('--------------------------');
end;
{dibuja cartas}
procedure CartaNumPaloFilaCol(num:integer;
palo:integer;col:integer;
fil:integer);
var numerocorrecto, palocorrecto, cartacorrecta: boolean;
numtxt, palotxt: string;
begin
case num of
1: numtxt:='A';
2: numtxt:='2';
3: numtxt:='3';
4: numtxt:='4';
5: numtxt:='5';
6: numtxt:='6';
7: numtxt:='7';
8: numtxt:='8';
9:numtxt:='9';
10: numtxt:='10';
11: numtxt:='J';
12: numtxt:='Q';
13: numtxt:='K';
else numerocorrecto:=false;
end;
palocorrecto:=true;
case palo of
1: palotxt:=chr(3); {corazones}
2: palotxt:=chr(4); {diamantes}
3: palotxt:=chr(5); {tr‚boles}
4: palotxt:=chr(6); {picas}
else palocorrecto:=false;
end;
cartacorrecta:= palocorrecto and palocorrecto;
if cartacorrecta=true then
begin
if palo <3 then textcolor(12) else textcolor(0);
gotoxy(col,fil); write('ÉÍÍÍÍÍ»');
gotoxy(col,fil+1); write('º º');
gotoxy(col,fil+2); write('º º');
gotoxy(col,fil+3); write('º º');
gotoxy(col,fil+4); write('ÈÍÍÍÍͼ');
gotoxy(col+1,fil+1); write(numtxt);
gotoxy(col+3,fil+2); write(palotxt);
gotoxy(col+5,fil+3); write(numtxt);
end
else
write('Carta incorrecta!!');
end;
{##################################################################}
{principio programa}
{###################################################################}
BEGIN
for I:=1 to 10 do
begin
puntos:=0;
clrscr;
delay(100);
textcolor(4);
gotoxy(8,5);writeln('²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²² ');
gotoxy(8,6);writeln('²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²² ');
gotoxy(8,7);writeln('² ²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²² ');
gotoxy(8,8);writeln('² ²²²² ² ²²²²² ² ² ²² ²²² ² ² ² ²² ²² ');
gotoxy(8,9);writeln('² ²²²² ² ²²²²² ²²² ² ²²²² ² ²²²²²²² ²²²² ²²² ² ²²²²² ² ²²² ');
gotoxy(8,10);writeln('² ²² ²²²²² ² ²²²² ²²²²²²²² ²²²² ² ²²²²² ²²²² ');
gotoxy(8,11);writeln('² ²²²² ² ²²²²² ²²² ² ²²²² ²²²²²²²² ²²²² ²²² ² ²²²²² ²²²² ');
gotoxy(8,12);writeln('² ²²²² ² ²²²²² ²²² ² ²²²² ² ²²² ²²² ²²²² ²²² ² ²²²²² ² ²²² ');
gotoxy(8,13);writeln('² ²² ² ²²² ² ² ²² ²² ²²²² ²²² ² ² ²² ²² ');
gotoxy(8,14);writeln('²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²² ');
delay(100);
textcolor(3);
gotoxy(8,5);writeln('²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²² ');
gotoxy(8,6);writeln('²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²² ');
gotoxy(8,7);writeln('² ²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²² ');
gotoxy(8,8);writeln('² ²²²² ² ²²²²² ² ² ²² ²²² ² ² ² ²² ²² ');
gotoxy(8,9);writeln('² ²²²² ² ²²²²² ²²² ² ²²²² ² ²²²²²²² ²²²² ²²² ² ²²²²² ² ²²² ');
gotoxy(8,10);writeln('² ²² ²²²²² ² ²²²² ²²²²²²²² ²²²² ² ²²²²² ²²²² ');
gotoxy(8,11);writeln('² ²²²² ² ²²²²² ²²² ² ²²²² ²²²²²²²² ²²²² ²²² ² ²²²²² ²²²² ');
gotoxy(8,12);writeln('² ²²²² ² ²²²²² ²²² ² ²²²² ² ²²² ²²² ²²²² ²²² ² ²²²²² ² ²²² ');
gotoxy(8,13);writeln('² ²² ² ²²² ² ² ²² ²² ²²²² ²²² ² ² ²² ²² ');
gotoxy(8,14);writeln('²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²² ');
end;
repeat
acum:=0;
acum1:=0;
col:=0;
randomize;
textbackground(2);
clrscr;
textcolor(5);
writeln('Pantalla Principal, pulse ENTER para jugar esta mano, Balance--> ',puntos);
readln;
clrscr;
{##################BUCLE############################################}
repeat
Carta:=random(13)+1;
Palo:=random(4)+1;
col:=col+8;
CartaNumPaloFilaCol(Carta,Palo,col,1);
IF (carta>10) then carta:=10;
If (carta=1) and (acum<=10) then carta:=11;
Acum:=acum+carta;
if (acum<=21) then
begin
if (acum=21) then cartelblackjack;
if (acum<21) then cartel1(acum);
opc:=readkey;
end
else Cartelteaspasado;
until (acum>=21) or (opc='p');
{##############################FIN BUCLE##############################}
writeln('.......... Tienes ',acum,'. Veamos que hace la maquina ..........');
delay(1000);
Carta:=0;
palo:=0;
col:=0;
acum1:=0;
repeat
Carta:=random(13)+1;
Palo:=random(4)+1;
col:=col+8;
CartaNumPaloFilaCol(Carta,Palo,col,15);
IF (carta>10) then carta:=10;
If (carta=1) and (acum1<=10) then carta:=11;
Acum1:=acum1+carta;
until ((acum1>acum)and (acum<=21)) or ((acum1>=17)and (acum>21));
if ((acum1>acum) and (acum1<=21)) then
begin
textcolor(14);
gotoxy(40,15); writeln('--------------------------');
gotoxy(40,16); writeln('| HAS PERDIDO |');
gotoxy(40,17); writeln('| |');
gotoxy(40,18); writeln('| La maquina tiene: ',acum1);
gotoxy(40,19); writeln('| Usted Tiene: ',acum);
gotoxy(40,20);writeln('--------------------------');
puntos:=puntos-25;
end ;
if (((acum>acum1) and (acum<=21)) or ((acum<acum1) and (acum1>21))) then
begin
textcolor(14);
gotoxy(40,15); writeln('--------------------------');
gotoxy(40,16); writeln('| HAS GANADO ');
gotoxy(40,17); writeln('| |');
gotoxy(40,18); writeln('| La maquina tiene: ',acum1);
gotoxy(40,19); writeln('| Usted Tiene: ',acum);
gotoxy(40,20);writeln('--------------------------');
puntos:=puntos+25;
end
else
if (acum1>21) and (acum>21) then
begin
textcolor(14);
gotoxy(40,15); writeln('--------------------------');
gotoxy(40,16); writeln('| EMPATE, AMBOS JUGADORES|');
gotoxy(40,17); writeln('| SE PASARON |');
gotoxy(40,18); writeln('| La maquina tiene: ',acum1);
gotoxy(40,19); writeln('| Usted Tiene: ',acum);
gotoxy(40,20);writeln('--------------------------');
end
else
begin
textcolor(14);
gotoxy(40,15); writeln('--------------------------');
gotoxy(40,16); writeln('| HAS PERDIDO ');
gotoxy(40,17); writeln('| |');
gotoxy(40,18); writeln('| La maquina tiene: ',acum1);
gotoxy(40,19); writeln('| Usted Tiene: ',acum);
gotoxy(40,20);writeln('--------------------------');
end;
readln;
clrscr;
writeln('¿quieres otra? s/n');
opc:=readkey;
until opc='n';
END.

a ver ... te doy la idea, es una matriz y lo único que haces es apuntar un índice
bueno, lo tienes muy sencillo.... o lo haces generando ascii o simplemente como un
puntero , como seria eso?? de las muchas posibilidades que tienes supongo que
también tendrás que tener los palos entonces tenes que hacer matriz bidimensional
selanabar palo, carta: 1.... K y sacar una carta es bien sencillo en la matriz tienes
13 cartas 1 al 10 y las otras (J Q K ) bien ya tenes las posiciones ahora selanabar
un generador de números aleatorios, luego que no tenga repetición en función de la
carta que saques anteriormente y, el resultado es el puntero de las cartas que
tienes: 1 posición por carta el resto, es representación .

Mas o menos asi es como deberias hacerlo !! te mando un saludo!!!

Edit : ahhh me olvide y para realizarlo te sugiero Lazarus que no es otra cosa que
freepascal con un ide.
PROGRAM BLACKJACK;
USES CRT;
TYPE
CARDTYPE = RECORD
INDECK : BOOLEAN;
SUIT : CHAR;
FACE : INTEGER;
END;
PLAYERTYPE = RECORD
TOTAL : INTEGER;
NUMCARDS : INTEGER;
CARDS : ARRAY[1..5] OF INTEGER;
END;

VAR
DECK : ARRAY [1..52] OF CARDTYPE;

PROCEDURE SHUFFLE;
VAR COUNT : INTEGER;
BEGIN
FOR COUNT:=1 TO 52 DO
BEGIN
WITH DECK[COUNT] DO BEGIN
INDECK:=TRUE;
SUIT:=(CHR(((COUNT-1) DIV 13)+3));
IF (COUNT MOD 13)<> 0 THEN
FACE:=(COUNT MOD 13)
ELSE
FACE:=13;
END;
END;
END;

PROCEDURE MAKEPLAYER(VAR PLAYER : PLAYERTYPE);

VAR COUNT : INTEGER;
BEGIN
WITH PLAYER DO BEGIN
TOTAL:=0;
NUMCARDS:=0;
FOR COUNT:=1 TO 5 DO
CARDS[COUNT]:=0;
END;
END;

PROCEDURE VALUE (VAR PLAYER : PLAYERTYPE; PLAYERNUM : INTEGER);

VAR
VALUE, TOTAL : INTEGER;
BEGIN
TOTAL:=0;
CASE DECK[PLAYER.CARDS[PLAYER.NUMCARDS]].FACE OF
2..10 :
TOTAL:=DECK[PLAYER.CARDS[PLAYER.NUMCARDS]].FACE;
11..13 :
TOTAL:=10;
1:
BEGIN
IF PLAYERNUM=1 THEN IF TOTAL>10 THEN TOTAL:=TOTAL+1 ELSE TOTAL:=TOTAL+11
ELSE BEGIN
REPEAT
GOTOXY(1,23);
WRITELN('DO YOU WANT YOUR ACE TO COUNT AS A 1 OR 11?');
READLN(VALUE);
WRITELN(VALUE);
UNTIL (VALUE IN [1,11]) AND (IORESULT=0);
TOTAL:=VALUE;
END;
END;
END;
PLAYER.TOTAL:=PLAYER.TOTAL+TOTAL;
END;

PROCEDURE HITME(VAR PLAYER : PLAYERTYPE; PLAYERNUM : INTEGER);

VAR CARD : INTEGER;
BEGIN
REPEAT
CARD:=RANDOM(52);
UNTIL ((CARD<>0) AND (DECK[CARD].INDECK<>FALSE));
IF PLAYER.NUMCARDS<>5 THEN BEGIN
DECK[CARD].INDECK:=FALSE;
PLAYER.CARDS[PLAYER.NUMCARDS+1]:=CARD;
PLAYER.NUMCARDS:=PLAYER.NUMCARDS+1;
END;
VALUE(PLAYER,PLAYERNUM);
END;

PROCEDURE DISPLAYCARDS (PLAYERNUM, NUMCARDS : INTEGER; PLAYER : PLAYERTYPE);

VAR COUNT : INTEGER;
BEGIN
GOTOXY(20,1);
WRITE('COMPUTER''S CARDS');
GOTOXY(40,1);
WRITE('HUMAN''S CARDS');
FOR COUNT:=1 TO NUMCARDS DO BEGIN
GOTOXY(PLAYERNUM*20,COUNT+1);
CASE DECK[PLAYER.CARDS[COUNT]].FACE OF
1 : WRITE('A');
2..10 : WRITE(DECK[PLAYER.CARDS[COUNT]].FACE);
11 : WRITE('J');
12 : WRITE('Q');
13 : WRITE('K');
END;
WRITE(DECK[PLAYER.CARDS[COUNT]].SUIT);
GOTOXY(PLAYERNUM*20,10);
IF PLAYERNUM=2 THEN WRITE('TOTAL OF CARDS: ',PLAYER.TOTAL);
END;
END;

PROCEDURE PLAY(VAR HUMAN,COMPUTER : PLAYERTYPE);

VAR DONE : BOOLEAN;
YESNO : CHAR;
BEGIN
DONE:=FALSE;
REPEAT
REPEAT
GOTOXY(1,23);
WRITELN('DO YOU WANT ANOTHER CARD?');
READLN(YESNO);
YESNO:=UPCASE(YESNO);
UNTIL (IORESULT=0) AND (YESNO IN ['Y','N']);
IF YESNO='Y' THEN HITME(HUMAN,2) ELSE DONE:=TRUE;
CLRSCR;
DISPLAYCARDS(1,1,COMPUTER);
DISPLAYCARDS(2,HUMAN.NUMCARDS,HUMAN);
UNTIL (DONE=TRUE) OR (HUMAN.TOTAL>20);
END;

PROCEDURE COMPUTERPLAY(VAR HUMAN,COMPUTER : PLAYERTYPE);

VAR DONE : BOOLEAN;
BEGIN
DISPLAYCARDS(1,COMPUTER.NUMCARDS,COMPUTER);
DISPLAYCARDS(2,HUMAN.NUMCARDS,HUMAN);
DONE:=FALSE;
REPEAT
IF COMPUTER.TOTAL>17 THEN DONE:=TRUE ELSE HITME(COMPUTER,1);
DISPLAYCARDS(1,COMPUTER.NUMCARDS,COMPUTER);
DISPLAYCARDS(2,HUMAN.NUMCARDS,HUMAN);
GOTOXY(20,10);
WRITE('TOTAL OF CARDS: ',COMPUTER.TOTAL);
UNTIL (DONE=TRUE) OR (COMPUTER.TOTAL>20);
END;

PROCEDURE WINNER(HUMAN, COMPUTER : PLAYERTYPE);

VAR COMPWON : BOOLEAN;
BEGIN
COMPWON:=TRUE;
IF (HUMAN.TOTAL>=22) THEN
COMPWON:=TRUE
ELSE IF (COMPUTER.TOTAL>=22) THEN
COMPWON:=FALSE;
IF (COMPUTER.TOTAL>=HUMAN.TOTAL) AND (COMPUTER.TOTAL<=21) THEN
COMPWON:=TRUE
ELSE IF(HUMAN.TOTAL<=21) THEN
COMPWON:=FALSE;
IF COMPWON THEN
BEGIN
GOTOXY(37,23);
WRITELN('I WIN!');
END
ELSE
BEGIN
GOTOXY(36,23);
WRITELN('YOU WIN!');
END;
READLN;
END;
PROCEDURE DEAL;
VAR COMPUTER, HUMAN : PLAYERTYPE;
COUNT : INTEGER;
BEGIN
SHUFFLE;
MAKEPLAYER(COMPUTER);
MAKEPLAYER(HUMAN);
FOR COUNT:=1 TO 2 DO BEGIN
HITME(COMPUTER,1);
HITME(HUMAN,2);
CLRSCR;
DISPLAYCARDS(1,1,COMPUTER);
DISPLAYCARDS(2,HUMAN.NUMCARDS,HUMAN);
END;
PLAY(HUMAN,COMPUTER);
COMPUTERPLAY(HUMAN,COMPUTER);
WINNER(HUMAN,COMPUTER);
END;

PROCEDURE MENU;
VAR CHOICE : INTEGER;
BEGIN
REPEAT
REPEAT
CLRSCR;
GOTOXY(30,12);
WRITELN('***BLACKJACK***');
GOTOXY(30,15);
WRITELN('1 TO PLAY HAND');
GOTOXY(30,16);
WRITELN('2 TO EXIT');
WRITELN('ENTER YOUR CHOICE : ');
READLN(CHOICE);
UNTIL CHOICE IN [1,2];
CASE CHOICE OF
1 : DEAL;
2 : HALT;
END;
UNTIL CHOICE=2;
END;

BEGIN
RANDOMIZE;
CLRSCR;
MENU;
READKEY;
END.