necesito pasar de pascal a c++

[regore]

hola me pueden ayudar a pasarlo a c
por favor...
gracias



program bingo;

uses crt, graph;
const
(*constante para la matriz de los cartones*)
constante1=5;
(*constante para el vector de la tombola*)
constante2=100;
type
(*crea variable de tipo matriz de tipo entero*)
cartondebingo=array [1..constante1,1..constante1] of integer;
(*crea variable de tipo vector de tipo *boolean* (verdadero o falso) *)
tombola=array[1..constante2] of boolean;
(*crea variable de tipo vector de tipo *byte* de (0 a 255) *)
esfera=array [1..constante2] of byte;
verificador=array[1..constante1,1..constante1]of boolean;


var
controlgr : integer;
modogr : integer;
n:byte;
x1,x2,y1,y2,despy:integer;
esferadebingo:esfera;
yasalio:tombola;
convierteastring:string;
convierteastring2:string;
decision:char;
letrabingo:char;
numerofila:char;
columna:byte;
fila:byte;
contavecesnumero:byte;
carton1:cartondebingo;
carton2:cartondebingo;
cartones1y2:cartondebingo;
cartonverificador1:verificador;
cartonverificador2:verificador;
w,r,t,y:byte;
tienequerevisar:boolean;
gano:boolean;
cartones:byte;
cartones2:byte;
cartones3:byte;
cartones4:byte;


(*llena los cartones 1 y 2 de numeros *)
procedure llenecartones1y2;
var

k,l:byte;
mystring : string;
tempx1,tempy1:integer;
valido:boolean;
x:byte;
begin

(*Se genera la matriz de numeros aleatorios *)
for k:=1 to constante1 do
for l:=1 to constante1 do
begin
repeat
cartones1y2[k,l]:=random(100)+1;
(*evita que se salga del rango de la columna*)
until ( cartones1y2[k,l] > 20 * (k - 1) ) and
(cartones1y2[k,l] < 20 * k );

(*comparar los numeros y si se repite lo cambia*)
for x:=1 to l-1 do
if cartones1y2[k,l]=cartones1y2[k,x] then

(*repite hasta que los numeros no se repitan*)
(* y hasta que el numero generado no se salga del
rango*)
repeat
cartones1y2[k,l]:=random(99);
valido:=true;
if cartones1y2[k,l]<20*(k-1) then
valido:=false;

if cartones1y2[k,l]>20*k then
valido:=false;

if cartones1y2[k,l]=cartones1y2[k,x] then
valido:=false;

until valido=true;




end;


(*Dibuja los numeros de la matriz en el carton*)
(*muestra el estilo de texto*)
settextstyle(0,0,1);
tempx1:=x1 - 20;
tempy1:=y1 - 20;
for k:=1 to constante1 do
for l:=1 to constante1 do
begin (*for*)
(*convierte a una cadena de caracteres*)
(*la matriz de numeros aleatorios del bingo*)
str(cartones1y2[k,l],mystring);
(*escribe en el carton de la pantalla los numeros*)
outtextxy(tempx1+k*despy,tempy1+l*despy,mystring);
end (*for*)

end;

(*procedimiento que emite sonido al mostrar un numero*)
(*Los parametros de entrada son:*)
(*freq:frecuencia y duracion: La duracion del mismo ambos de tipo entero*)
Procedure Beep(Freq,Duracion : integer);
begin
sound( freq);
delay(duracion);
nosound;
end;
(*revisa si en alguno de los cartones(pc o usuario) se formo en fila*)
(*tiene de parametro de entrada carton que indica cual de los cartones es*)
(*si es carton = 1 se refiere al del usuario*)
(*si es carton = 2 se refiere a de la pc*)

(*procedimiento que permite oir un ciclo de tonos al inicio o cuando alguno
de los cartones ganan*)
procedure cancioninicioyfinal;
var contatonos:byte;
begin
contatonos:=0;
repeat
contatonos:=contatonos + 1;
beep(700,500);
beep(600,200);
beep(500,600);
beep(400,800);
beep(700,200);

until contatonos = 3;
end;

procedure revisaganocolumna(cartones:byte);

var ganotemporal:boolean;

begin(*procedimiento revisaganofila*)
ganotemporal:=false;
(*revisa si alguna columna esta llena*)
for w:=1 to 5 do
begin(*for*)
gano:=true;
if cartones = 1 then
begin(*if carton=1*)
if cartonverificador1[w,1] = false then
gano:=false;
if cartonverificador1[w,2] = false then
gano:=false;
if cartonverificador1[w,3] = false then
gano:=false;
if cartonverificador1[w,4] = false then
gano:=false;
if cartonverificador1[w,5] = false then
gano:=false;
if gano then ganotemporal:=gano;
end(*if cartones = 1*)
else(*carton =1*)
begin(*ELSE*)
if cartones = 2 then
begin(*if*)
(*gano:=true;*)

if cartonverificador2[w,1] = false then
gano:=false;
if cartonverificador2[w,2] = false then
gano:=false;
if cartonverificador2[w,3] = false then
gano:=false;
if cartonverificador2[w,4] = false then
gano:=false;
if cartonverificador2[w,5] = false then
gano:=false;
if gano then ganotemporal:=gano;
end;(*if cartones=2*)
end;(*else*)
end;(*for*)
gano:=ganotemporal;
end;(*procedimiento revisagafila*)

(*este procedimiento se encarga de revisar si en alguno de los cartones*)
(*se formo una columna*)
(*tiene como entrada cartones2 el cual indica cual de los cartones se debe
revisar*)
procedure revisaganofila(cartones:byte);
var
ganotemporal:boolean;
begin(*procedimiento revisaganocolumna*)
ganotemporal:=false;
(*recorre por fila*)
for W:=1 to 5 do
begin(*for*)
gano:=true;
if cartones = 1 then
begin(*if*)
if cartonverificador1[1,w] = false then
gano:=false;
if cartonverificador1[2,w] = false then
gano:=false;
if cartonverificador1[3,w] = false then
gano:=false;
if cartonverificador1[4,w] = false then
gano:=false;
if cartonverificador1[5,w] = false then
gano:=false;
if gano then ganotemporal:=gano;
end(*if*)

else
begin(*else*)
if cartones = 2 then
begin(*if*)
if cartonverificador2[1,w] = false then
gano:=false;
if cartonverificador2[2,w] = false then
gano:=false;
if cartonverificador2[3,w] = false then
gano:=false;
if cartonverificador2[4,w] = false then
gano:=false;
if cartonverificador2[5,w] = false then
gano:=false;
if gano then ganotemporal:=gano;

end;(*if*)
end;(*else*)
end;(*for*)
gano:=ganotemporal;

end;(*procedimiento revisaganocolumna*)

(*procedimiento que revisa si alguno de los 2 cartones se formo una
diagonal / *)
procedure revisaganodiagonal(cartones:byte);
var
ganotemporal:boolean;

begin(*procedimiento revisaganodiagonal*)
ganotemporal:=false;
gano:=true;
if cartones = 1 then
begin(*if*)
if cartonverificador1[1,1] = false then
gano:=false;
if cartonverificador1[2,2] = false then
gano:=false;
if cartonverificador1[3,3] = false then
gano:=false;
if cartonverificador1[4,4] = false then
gano:=false;
if cartonverificador1[5,5] = false then
gano:=false;
if gano then ganotemporal:=gano;
end(*if*)

else
begin(*else*)
if cartones = 2 then
begin(*if*)
if cartonverificador2[1,1] = false then
gano:=false;
if cartonverificador2[2,2] = false then
gano:=false;
if cartonverificador2[3,3] = false then
gano:=false;
if cartonverificador2[4,4] = false then
gano:=false;
if cartonverificador2[5,5] = false then
gano:=false;
if gano then ganotemporal:=gano;
end;(*if*)
end;(*else*)


gano:= ganotemporal;
end;(*procedimiento revisaganodiagonal*)


(*procedimiento que revisa se se formo una diagonal \ en alguno de los 2
cartones*)
procedure revisaganodiagonal2(cartones:byte);
var
ganotemporal:boolean;
begin(*revisaganodiagonal2*)
ganotemporal:=false;
for w:=1 to 5 do
begin(*for*)
gano:=true;
if cartones4 = 1 then
begin(*if*)
if cartonverificador1[5,1] = false then
gano:=false;
if cartonverificador1[4,2] = false then
gano:=false;
if cartonverificador1[3,3] = false then
gano:=false;
if cartonverificador1[2,4] = false then
gano:=false;
if cartonverificador1[1,5] = false then
gano:=false;
if gano then ganotemporal:=gano;
end(*if*)

else
begin(*else*)
if cartones = 2 then
begin(*if*)
if cartonverificador2[5,1] = false then
gano:=false;
if cartonverificador2[4,2] = false then
gano:=false;
if cartonverificador2[3,3] = false then
gano:=false;
if cartonverificador2[2,4] = false then
gano:=false;
if cartonverificador2[5,1] = false then
gano:=false;
if gano then ganotemporal:=gano;
end;(*if*)
end;(*else*)

end;(*for*)
gano:=ganotemporal;

end;(*procedimiento revisaganodiagonal2*)


(*procedimiento que llama a los procedimientos de opciones de ganar el
bingo*)
procedure llamaganadores;
var
RevisandoCarton :byte;
QuienGana: string;
Ganador:string;
Alguiengano:boolean;
elquegano:byte;
begin (*Del procedimiento*)
alguiengano:=false;
for revisandoCarton:=1 to 2 do
begin(*Ciclo de revision de cartones*)
gano:=false;
revisaganocolumna(revisandocarton);
if gano then alguiengano:=true;
revisaganofila(revisandocarton);
if gano then alguiengano:=true;
revisaganodiagonal(revisandocarton);
if gano then alguiengano:=true;
revisaganodiagonal2(revisandocarton);
if gano then alguiengano:=true;
if alguiengano then
begin(*1*)
elquegano:=revisandocarton;
settextstyle(0,0,3);
setcolor(blue);
str(elquegano,ganador);
quiengana:='Gana Jugador '+ganador;
outtextxy(100,100,quiengana);
cancioninicioyfinal;
gano:=alguiengano;
end;(*1*)


end;(*End del ciclo de revision de cartones*)

end; (*Del procedimiento*)
(*procedimiento que se encarga de mostrar los 2 cartones en la pantalla*)
procedure carton;
begin(*procedimiento carton*)

(* cambia estilo de relleno x=estilo de relleno y=color*)
setfillstyle(1,2);
(*dibuja el rectangulo de fondo*)
bar(x1-20,y1-50,x2+20,y2+20);
(*estilo de texto x=tipo letra y=orientacion z=tama¤o*)
settextstyle(1,0,3);
(*muestra el texto BINGO*)
outtextxy(x1+10,y1-30, 'B' );
outtextxy(x1+40,y1-30,'I');
outtextxy(x1+70,y1-30,'N');
outtextxy(x1+100,y1-30,'G');
outtextxy(x1+130,y1-30,'O');

(*lineas horizontales del carton*)
line(x1,y1,x2,y1);
line(x1,y1+despy,x2,y1+despy);
line(x1,y1+2*despy,x2,y1+2*despy);
line(x1,y1+3*despy,x2,y1+3*despy);
line(x1,y1+4*despy,x2,y1+4*despy);
line(x1,y1+5*despy,x2,y1+5*despy);

(*lineas verticales del carton*)
line(x1,y1,x1,y2);
line(x1+despy,y1,x1+despy,y2);
line(x1+2*despy,y1,x1+2*despy,y2);
line(x1+3*despy,y1,x1+3*despy,y2);
line(x1+4*despy,y1,x1+4*despy,y2);
line(x1+5*despy,y1,x1+5*despy,y2);
(*llama al procedimiento llenecartones1y2*)
llenecartones1y2;

end;(*procedimiento carton*)


(* se encarga de llenar con numeros aleatorios la tombola del bingo*)
procedure llenetombola;

var
m,contador:byte;
yaexiste:boolean;
numerogenerado:byte;

begin(*procedimiento tombola*)

(*llama funcion de random*)
randomize;

(*Lleva el conteo de la matriz yasalio*)
for contador:=1 to constante2 do
yasalio[contador]:=false;

for m:=1 to (constante2 -1) do

(*este ciclo se repite hasta se compruebe que un numero
ya fue generado*)
repeat
(*crea un numero aleatorio entre 0 y 99*)
numerogenerado:=random(99);

(*si el numero generado ya habia salido se vuelve
a generar otro numero*)
(*si el numero generado no habia salido se manda a
la matriz esferadebingo*)

if yasalio[numerogenerado] then

(*llega a esta sentencia si el numero ya habia
salido*)
yaexiste:=true

(*Ingresa al else si numerogenerado no habia
salido antes*)
else
begin(*else*)

yaexiste:= false;
yasalio[numerogenerado]:=true;
(*en la posicion que se esta recorriendo
hay guarda el numero generado*)
esferadebingo[m]:=numerogenerado;

end;(*else*)
until yaexiste=false;

end;(*procedimiento llenetombola*)


(*procedimiento para marcar una casilla dentro del carton*)
(*marcacelda(x,y,z)*)
(*x=carton, y=fila, z=columna*)
procedure Marcacelda(carton,fila,columna:integer);

var
xinicial,yinicial:integer;
mytempstring:string;

begin(*procedimiento marcacelda*)

(*la posicion x inicial de los cartones*)
yinicial:=150;
(*marca en color rojo*)
setcolor(red);
(*revisa cual carton es, dependiendo del carton se deben cambiar*)
(*la coordenada x para dibujar y tambien hay que ver cual es el numero*)
(*que hay en la casilla*)

if carton = 1 then
begin(*if*)
xinicial:=100;
str(carton1[columna,fila],mytempstring);
end;(*if*)

if carton = 2 then
begin(*if*)
xinicial:=400;
str(carton2[columna,fila],mytempstring);
end;(*if*)

(*define el mismo tama¤o de texto usado para llenar el carton*)
settextstyle(0,0,1);
(*dibuja un circulo alrededor del numero*)
circle(xinicial+30*columna-15,yinicial+30*fila-15,10);
(*escribe el numero en la misma posicion en rojo*)
outtextxy(columna*30+xinicial-20,fila*30+yinicial-20,mytempstring);
End;(*finaliza procedimiento marcacelda*)


(*procedimiento que permite marcar en el carton de la pc*)
(*el numero que salio de la tombola*)
(*tiene parametro de entrada numero de tipo interno*)
procedure revisacarton(numero:integer);

begin
for w:=1 to constante1 do
for r:=1 to constante1 do
if numero = carton2[w,r] then
begin
cartonverificador2[w,r]:=true;
marcacelda(2,r,w);
beep(1000,100);
end;
end;
(***************************************************************************)
begin(*PRINCIPAL*)
(*llama a la funcion de random*)
clrscr;
randomize;
(*se utilizan para modo grafico*)
controlgr:=detect;
initgraph(controlgr,modogr,' ');
cancioninicioyfinal;
(*inicializa las variables del carton 1*)
x1:=100;
x2:=250;
y1:=150;
y2:=300;
despy:=30;
(*llama al procedimiento carton*)
carton;
carton1:=cartones1y2;
(*inicializa las variables del carton 2*)
x1:=400;
x2:=550;
y1:=150;
y2:=300;
despy:=30;

(*llama al procedimiento carton*)
carton;
carton2:=cartones1y2;

(*llama al procedimiento llenetombola*)
llenetombola;

(*muetra el texto de usuario en la pantalla*)
settextstyle(5,0,1);
setcolor(white);
outtextxy(130,330,'Usuario');

settextstyle(5,0,1);
setcolor(white);
outtextxy(430,330,'Computadora');

(*muestra el texto el numero es*)
settextstyle(1,0,3);
outtextxy(150,390,'El numero es:');

settextstyle(1,0,2);
setcolor(6);
outtextxy(50,1,'Presione la tecla espacio para cambiar de numero');

(*muestra el texto x:200 y Y:450*)
settextstyle(5,0,1);
setcolor(9);
outtextxy(200,450,'Presione la tecla x o X para salir');
contavecesnumero:=0;
n:=1;
(*se encarga de llenar las 2 matriz booleanas de false*)
for w:=1 to constante1 do
for r:=1 to constante1 do
begin
cartonverificador1[w,r]:=false;
cartonverificador2[w,r]:=false;
end;

(*es ciclo permite mostrar el numero de la tombola en la pantalla*)
repeat
(*el numero que ya salio lo convierte a color negro para borrarlo*)
settextstyle(1,0,5);
str(esferadebingo[n-1],convierteastring);
setcolor(black);
outtextxy(400,380,convierteastring);
(*muestra el numero en color blanco*)
str(esferadebingo[n],convierteastring);
setcolor(white);
outtextxy(400,380,convierteastring);


(*debe revisar si el numero que salio esta en el carton de la pc*)
(*recorrer el carton para ver si el numero existe ahi*)
(*si el numero existe debe marcar el carton*)
(*actualizar la matriz de variables booleanas*)
revisacarton(esferadebingo[n]);
(*si el usuario presiono un tecla B-I-N-G-O y un numero entre el 1
y el 5*)
(*debe revisar si el usuario tiene el numero, en este caso*)
(*se debe revisar solamente la casilla que el usuario digito*)
(*si es igual entonces hay que marcar la casilla y actualizar la*)
(*matriz de variables booleanas*)
settextstyle(0,0,1);
setcolor(blue);
outtextxy(10,50,'Teclee el numero de letra');

letrabingo:=readkey;

case letrabingo of
'B','b': columna:=1;
'I','i': columna:=2;
'N','n': columna:=3;
'G','g': columna:=4;
'O','o': columna:=5;
end;



(*muestra el texto que pide el # de fila*)
settextstyle(0,0,1);
setcolor(blue);
outtextxy(12,70,'Mencione el numero de la fila');
numerofila:=readkey;

case numerofila of
'1': fila:=1;
'2': fila:=2;
'3': fila:=3;
'4': fila:=4;
'5': fila:=5;
end;
if carton1[columna,fila] = esferadebingo[n] then
begin
marcacelda(1,fila,columna);
beep(1000,500);
cartonverificador1[fila,columna]:=true;
end;
llamaganadores;
n:=n + 1;

(*aumenta el contador de numeros salidos*)
contavecesnumero:= contavecesnumero + 1;
(*convierte el valor # de contavecesnumero a una cadena de
caracteres*)
(*hace que el numero que ya se mostro se convierta a negro*)
(*y asi el numero siguiente se muestra en blanco*)
str((contavecesnumero-1),convierteastring2);
(*muestra el texto 'han salido' de x:10 y Y:350*)
settextstyle(5,0,1);
setcolor(yellow);
outtextxy(10,350,'Han salido');
(*muestra en pantalla la cantidad de numeros que han salido en x:100
y Y:350*)
setcolor(black);
(*muestra en pantalla la cantidad de numeros que han salido*)
outtextxy(100,350,convierteastring2);

str(contavecesnumero,convierteastring2);
settextstyle(5,0,1);
setcolor(white);
outtextxy(100,350,convierteastring2);
(*muestra el texto 'numeros' en x:130 y Y:350*)
(*color amarillo*)
settextstyle(5,0,1);
setcolor(yellow);
outtextxy(130,350,'Numeros');
(*decision captura una tecla*)
decision:=readkey;
if contavecesnumero > 100 then
decision:='x';

if gano then decision:='x';




(*se repite hasta que se teclee la letra 'x','X'*)
until decision in ['x','X'] ;

cancioninicioyfinal;
(*cierra el modo grafico*)
closegraph;
end.(*PRINCIPAL*)

[programmer]

¿Cuánto pagas? Si estás interesado mándame un MP, soy experto en ambos temas.
_________________
Uso Code::Blocks 8.02 bajo Windows XP y programo en C++
Uso el Microsoft Visual C++ 2008 Express Edition + glut + freeglut para gráficos OpenGL