Graficos Tortuga en C++ Con Apuntadores

Los ultimos dias he estado dandole al tema de los apuntadores en C++, que no es del todo facil, el concepto se entiende bien, pero la “sintaxis” varia y tienen muchos usos. Como para “aplicarlos” antes de entrar a los ejercicios en lleno (Juegos de cartas, Simuladores, Un simulador de computadora llamado “Simpletron”), pense en “remasterizar” uno de los ejercicios que habia desarrollado en el capitulo de los arreglos y que me habia gustado bastante. El ejercicio de Graficos de tortiga. El problema es basicamente el siguiente:

Imagina que sobre un piso, hay una tortuga. La tortuga, en cuestion, tiene una pluma que puede estar en dos posiciones, arriba y abajo. Mientras la pluma esta arriba, la tortuga se mueve libremente sin dejar rastros. Cuando la pluma esta abajo, la tortuga deja un rastro mientras se mueve. Su programa debe simular un piso mediante un arreglo de 20 x 20 y los movimientos de la tortuga. Los movimientos de la tortuga se realizaran mediante un comando introducido por el usuario. Los comandos disponibles son:

• 1. Pluma arriba
• 2. Pluma abajo
• 3. Mover Izquierda
• 4. Mover Derecha
• 5. Mover Arriba/Abajo
• 6. Desplegar Arreglo
• 9. Salir

Como ya habran supuesto, el problema lo resolvi y lo dejo aqui, tanto como para que lo lean, como para que yo tenga lo tenga aqui por si borro el archivo. Bueno, aqui esta el codigo:

EDITO: El codigo salia incompleto si lo ponia, asi que lo que hare sera subirlo a asvefile y darles los enlaces, lo siento, pero de que servia tenerlo incompleto ?

EDITO (nuevamente): El codigo lo pongo aqui… que se hace, es mucho mas facil. Aunque les advierto que esto es bastante viejo y la verdad no merece mucho la pena ponerse a verlo demasiado, es muy simple y a mi parecer feo . Ahora esta en su “version” linux, los que usen linux cambien system(”clear”) por system(”cls”) y getchar() por system(”pause”)

#include <iostream>
#include <iomanip>
#define LIMITE 20
#define BLANCO '_'
#define OCUPADO '*'
#define limpiar system("clear")
#define esperar getchar()

using namespace std;

void desplegar_a(char *piso, const int tamano,  const int pluma,  int *y, int *x ) {
     limpiar;
     cout << setw(23) << "PISO:\n";
     if (pluma == 1)
     *(piso + ( *x + *y ) ) = OCUPADO;
     char *temporal = piso + ( *x + *y );
     cout << setw( 6 );
     for (int contador = 0; contador != tamano * tamano; piso++, contador++) {
     cout  << *piso << setw( 2 );
     if (contador % LIMITE == 0 && contador != 1)
     cout << endl << setw( 6 );
     }

     if (pluma == 1)
     *temporal = BLANCO;

     cout << endl;
     cout << endl;
     esperar;

     }

void despliega_comandos() {
     limpiar;
     const char *comandos[6] = { "Pluma Arriba" , "Pluma abajo" , "Mover izquierda" , "Mover derecha" , "Mover arriba/abajo" , "Desplegar Arreglo" };
     cout << "*******************\nComandos\n*******************\n";
     for (int contador = 0; contador < 6 ; contador++)
     cout << "* " <<contador + 1 << ". " << comandos[contador] << endl;

     cout << "* 9. Salir" << endl;
     }

void mover_izquierda(char *piso, const int pluma, int *y, int *x ) {

     switch ( pluma ) {
            case 1:
            if (*x + 1 < LIMITE)
            *x += 1;

            else {
            cout << "No se pueden realizar movimientos a la izquierda" << endl;
            esperar;
            }
            break;

            case 2:
            if (*x + 1 < LIMITE )
            *x += 1;
            if (*x + 1 > LIMITE ) {
            cout << "No se pueden realizar movimientos a la izquierda" << endl;
            esperar;
            }

            *( piso + ( *x + *y ) ) = OCUPADO;
            break;
            }
            }

int mover_derecha(char *piso, const int pluma, int *y, int *x) {  

          switch ( pluma ) {
                 case 1:
                 if (*x - 1 >= 0)
                 *x -= 1;

                 else {
                    cout << "No se pueden realizar movimientos a la derecha" << endl;
                    esperar;
                    break;
                    }
                 break;

                 case 2:

                 if (*x - 1 < 0) {
                 cout << "No se pueden realizar movimientos a la derecha" << endl;
                 esperar;
                 }

                 if (*x - 1 >= 0)
                 *x -= 1;

                 *( piso + (*y + *x ) ) = OCUPADO;
                 }

}

int mueve_arriba(char *piso, const int pluma, int *y,int * x) {

     int contador = 0;
     int contador2 = 0;
     int n = 0;
     int arriba_abajo = 0;
     cout << "Desea moverlo arriba o abajo? (1 = arriba) (2 = abajo)" ;
     cin >> arriba_abajo;
     cout << "Numero de veces que se a mover: ";
     cin >> n;

     switch ( pluma ) {
            case 1:
                    if (arriba_abajo == 1 && *y + (LIMITE * n) > ( LIMITE * LIMITE) - 2) {
                    cout << "Imposible realizar la accion" << endl;
                    esperar;
                    break;
                    }

                    else {
                    switch ( arriba_abajo ) {
                    case 1:
                    *y = *y + (LIMITE * n);
                    break;

                    case 2:
                    if (*y - (LIMITE * n ) < 0) {
                    cout << "Imposible hacer" << endl;
                    esperar;
                    break;
                    }
                    *y = *y - (LIMITE * n );
                    break;
                    }
                    break;
                    }

            case 2:
                    if (arriba_abajo == 1 && n + *y > 19) {
                    cout << "El numero es mayor de lo que se puede mover la tortuga" << endl;
                    esperar;
                    break;
                    }

                    switch ( arriba_abajo ) {
                    case 1:
                         for (contador = 0; contador <= n * n; y++, contador++)
                         *( piso + ( *y + *x ) ) = OCUPADO;
                         y--;
                         break;

                    case 2:
                    if (*y - n < 0) {
                    cout << "No se puede mover hacia abajo" << endl;
                    esperar;
                    break;
                    }
                    for (contador = 0; contador <= n * n; y--, contador++)
                    *( piso + ( *y + *x ) ) = OCUPADO;
                    y++;
                    break;
                    }
                    break;
                    }
                    }

int main()
{
    const int tamano = 20;
    char piso[tamano][tamano] = {BLANCO};
    int comandos;
    int contador = 0;
    int contador2 = 0;
    int pluma = 1;
    int x = 1;
    int y = 0;
    int senal = 0;

    for (contador = 0; contador < tamano; contador++) {
        for (contador2 = 0; contador2 < tamano; contador2++) {
            piso[contador][contador2] = BLANCO;
            }

            }
    cout << "*********************\nTortuga\n*********************\n";
    cout << "El juego es sencillo, la unica regla es tratar de que la tortuga camine bastante"
    << "sin salirse del piso, para eso la moveras a tu gusto, a continuacion se te presentaran"
    << " los comandos disponibles, disfruta!" << endl;
    esperar;

    for (;senal == 0;) {
        limpiar;
        despliega_comandos();

        cout << "carlos@debian:> ";
        cin >> comandos;

        switch ( comandos ) {
        case 1:
        pluma = 1;
        break;

        case 2:
        pluma = 2;
        break;

        case 3:
        mover_izquierda( &piso[0][0] , pluma , &y , &x );
        break;

        case 4:
        mover_derecha( &piso[0][0] , pluma , &y , &x );
        break;

        case 5:
        mueve_arriba( &piso[0][0] , pluma , &y, &x );
        break;

        case 6:
        desplegar_a( &piso[0][0] , tamano, pluma, &y, &x );
        break;

        case 9:
        senal = 1;
        break;
        }
        if (comandos > 9)
        cout << "Comando invalido" << endl;
        limpiar;
        }

        esperar;
        return 0;
        }