[ansi c] torres de hanoi

[CrashNebula]

Estoy trabajando con las torres de hanoi. Quisiera que me ayudaran a descifrar
por qué mi código no funciona como debería.

El programa en debe ser gráfico y no narrativo. Algo como esto:
http://www.youtube.com/watch?v=xXTle8JYhys

Debo realizar el programa mediante funciones recursivas y no puedo utilizar métodos iterativos.

Las funciones donde probablemente esté el error son la g_MoverDiscos o g_TorreDeHanoiRecursiva.

En mi programa utilicé 3 arreglos unidimensionales para la "torres".
Uno que se llama Origen que se imprime a la izquierda, otro que se
llama intermedio que se imprime en el centro y el final se llama destino.





Mientras escribia esto note que los errores *parecen de impresión. :o. Creo que los
argumentos que se están pasando a la función imprimir se están cambiando debido a la
como tengo escrita la recursión en mi código. Alguna idea sobre como puedo solucionar
esto? (en caso de que esto sea el problema)

Cualquier ayuda es útil muchas gracias.

A continuación pondré las funciones donde creo que tengo el problema

Código C:

#define kMAX 30
void g_MoverDiscos(int liFilas,int liNDiscos,
 * * * * * * * * * int liTorreOrigen[kMAX],int liTorreDestino[kMAX])
{
 * *int liPosOrigen =0;
 * *int liPosDestino=liFilas-1;
 
 * *//Busqueda de la posicio del menor disco en el origen
 * *while(liTorreOrigen[liPosOrigen]==0 && liPosOrigen<liFilas-1)
 * *{
 * * * *liPosOrigen++;
 * *}
 
 * *//Busqueda de la posicion del tope de la torre destino
 * *while(liTorreDestino[liPosDestino]!=0 && liPosDestino>0)//Menor o igual
 * *{
 * * * *liPosDestino--;
 * *}
 * *liTorreDestino[liPosDestino]=liTorreOrigen[liPosOrigen];//Transferencia del disco
 * *liTorreOrigen[liPosOrigen]=0;//Al moverse el disco esta posicion se hace cero.
}
 
 
void g_TorreDeHanoiRecursivo(int liFilas, int liNDiscos,int liTorreOrigen[kMAX],
 * * * * * * * * * * * * * * int liTorreIntermedia[kMAX],int liTorreDestino[kMAX])
{
 
 * *if(liNDiscos==1)
 * *{
 
 * * * *g_MoverDiscos(liFilas, liNDiscos, liTorreOrigen, liTorreDestino);
 * * * *system("cls");
 * * * *g_ImprimirDiscos(liFilas, liTorreOrigen,
 * * * * * * * * * * * * liTorreIntermedia, liTorreDestino);
 
 * *}//END if
 * *else
 * *{
 * * * *g_TorreDeHanoiRecursivo(liFilas, liNDiscos-1,liTorreOrigen,
 * * * * * * * * * * * * * * * *liTorreDestino,liTorreIntermedia);
 
 * * * *g_MoverDiscos(liFilas, liNDiscos, liTorreOrigen, liTorreDestino);
 * * * *system("cls");
 * * * *g_ImprimirDiscos(liFilas, liTorreOrigen,
 * * * * * * * * * * * * *liTorreDestino,liTorreIntermedia);
 
 
 * * * *g_TorreDeHanoiRecursivo(liFilas, liNDiscos-1,liTorreIntermedia,
 * * * * * * * * * * * * * * * *liTorreOrigen,liTorreDestino);
 * *}//END else
}//END g_TorreDeHanoiRecursivo
 

///
/// Estas son las demás funciones de mi programa (todas estas están bien)
///

Código C:

/// Esta es para leer los discos
int giLeerDiscos(void)
{
 * *int liN;
 * *do
 * *{
 * * * *printf("\nIndique la cantidad de discos: ");
 * * * *scanf("%d",&liN);
 * * * *if(liN<1||liN>kMAX_DISCOS)
 * * * *{
 * * * * * *system("cls");
 * * * * * *printf("ERROR.OPCION NO ES VALIDA. VUELVA A INTENTAR\n\n");
 * * * *}
 * *}while(liN<1||liN>kMAX_DISCOS);
 * *return liN;
}
 
 
//Funcion incializa los arreglos a la condicion *que deben tener antes de jugar
void g_CondicionInicialHanoi(int liNDiscos,int liTorreOrigen[kMAX],
 * * * * * * * * * * * * * * int liTorreIntermedia[kMAX],int liTorreDestino[kMAX])
{
 * *int i;
 * *for (i=0;i<liNDiscos;i++)
 * *{
 * * * *liTorreOrigen[i]=i+1; * * * //Se colocan los discos desde el 1 en manera ascendente
 * * * *liTorreIntermedia[i]=0; * * //Se hace cero
 * * * *liTorreDestino[i]=0; * * * *//Se hace cero
 * *}
}
 
 
void g_ImprimirDiscos(int liFilas,int liTorreOrigen[kMAX],
 * * * * * * * * * * * *int liTorreIntermedia[kMAX],int liTorreDestino[kMAX])
{
 * *int i;
 
 * *for (i=0;i<liFilas;i++)
 * *{
 
 * * * *printf("%d\t",liTorreOrigen[i]);
 * * * *printf("%d\t",liTorreIntermedia[i]);
 * * * *printf("%d\t",liTorreDestino[i]);
 * * * *printf("\n");
 * *}
}
 
int *main()
{
 * *int liTorreOrigen[kMAX];
 * *int liTorreIntermedia[kMAX];
 * *int liTorreDestino[kMAX];
 * *int liNDiscos;
 * *int liFilas; // Es igual al numero inicial de discos. Define el espacio
 * * * * * * * * // de juego.
 
 
 * *liNDiscos=giLeerDiscos();
 * *liFilas=liNDiscos;
 * *//Condicion inicial del juego
 * *g_CondicionInicialHanoi(liNDiscos,liTorreOrigen,
 * * * * * * * * * * * * * *liTorreIntermedia,liTorreDestino);
 
 * *//Imprimir condicion inicial del juego
 * *system("cls");
 * *g_ImprimirDiscos(liNDiscos,liTorreOrigen,
 * * * * * * * * * * liTorreIntermedia,liTorreDestino);
 * *g_TorreDeHanoiRecursivo(liFilas, liNDiscos,liTorreOrigen,
 * * * * * * * * * * * * * *liTorreIntermedia,liTorreDestino);
 * *printf("\n");
return 0;
}