Foro de elhacker.net

Estoy intentando hacer el modo de usuario vs cpu ya tengo el de usuario1 vs usuario2 pero no entiendo como usar la funcion de random para hacer funcionar esto, si alguien me podria explicar se lo agradeceria.

Si quieres recibir ayuda de alguien, pónselo un poco más fácil a quien te intente ayudar...
Es un código bastante grande, la tabulación está regular y sin resaltado de sintaxis (en la etiqueta de apertura de code puedes poner "=c" o "=cpp" sin comillas para que se resalte la sintaxis de C o de C++ o directamente elegir el lenguaje del desplegable "Código GeSHi"). Además no especificas nada de tu problema. Obligas a quien te quiera ayudar a leerse el código entero... y te aseguro que no es para nada apetecible.

Lo siento pero me sentia desesperado ahora ya, me explico si es que puedes explicarme como puedo hacer que cuando jugador 1(yo) tire despues siga la maquina me entiendes?

#include<stdio.h>
#include<stdlib.h>
#include<windows.h>
#include<conio.h>
 
int tablero[3][3];
int col, fila;
int modo, ban;
int win;
int pos;
int player;
 
void gotoxy(int x,int y){
    HANDLE hcon;
    hcon = GetStdHandle(STD_OUTPUT_HANDLE);
    COORD dwPos;
    dwPos.X = x;
    dwPos.Y= y;
    SetConsoleCursorPosition(hcon,dwPos);
}
 
void escenario(){
    gotoxy(33,2); printf("#############");
    gotoxy(33,3); printf("# 1 # 2 # 3 #"); //35,3 39,3 43,3
    gotoxy(33,4); printf("#############");
    gotoxy(33,5); printf("# 4 # 5 # 6 #"); //35,5 39,5 43,5
    gotoxy(33,6); printf("#############");
    gotoxy(33,7); printf("# 7 # 8 # 9 #"); //35,7 39,7 43,7
    gotoxy(33,8); printf("#############");
 
    gotoxy(33,10); printf("#############");
    gotoxy(33,11); printf("#   #   #   #"); //35,11 39,11 43,11
    gotoxy(33,12); printf("#############");
    gotoxy(33,13); printf("#   #   #   #"); //35,13 39,13 43,13
    gotoxy(33,14); printf("#############");
    gotoxy(33,15); printf("#   #   #   #"); //35,15 39,15 43,15
    gotoxy(33,16); printf("#############");
}
 
 
main(){
    for(col=0; col<3; col++){
        for(fila=0; fila<3; fila++){
            tablero[col][fila]=5;
        }
    }
 
    do{
        system("cls");
        printf("El juego del Gato\n");
        ban=0;
        gotoxy(1,18);printf("Elija la modalidad de juego: 1 Usuario1 vs Usuario2 - 2 Usuario vs Maquina");
        gotoxy(1,19);printf("Modalidad: ");
        scanf("%d",&modo);
        if(modo == 1){
            ban=1;
            if(modo==1){
                gotoxy(1,20);printf("Usuario1 <<X>> vs Maquina <<O>>");
                escenario();
                win=0;
                player=1;
            }
            do{
                gotoxy(1,21); printf("En que cuadro quiere tirar: ");
                scanf("%d",&pos);
                if(pos>=1 && pos<=9){
                    switch(pos){
                        case 1:
                            if(tablero[0][0]==5){
                                if(player==1){
                                    tablero[0][0]=1;
                                    player=2;
                                    gotoxy(35,11);printf("%d",tablero[0][0]);
                                }
                                else{
                                    tablero[0][0]=0;
                                    player=1;
                                    gotoxy(35,11);printf("%d",tablero[0][0]);
                                }
                            }
                            else{
                                printf("La Casilla ya esta ocupada, intente de nuevo");
                            }
                            break;
 
                        case 2:
                            if(tablero[0][1]==5){
                                if(player==1){
                                    tablero[0][1]=1;
                                    player=2;
                                    gotoxy(39,11);printf("%d",tablero[0][1]);
                                }
                                else{
                                    tablero[0][1]=0;
                                    player=1;
                                    gotoxy(39,11);printf("%d",tablero[0][1]);
                                }
                            }
                            else{
                                printf("La Casilla ya esta ocupada, intente de nuevo");
                            }
                            break;
                    }
                }
 
            }while(win!=1);
 
        }
        else{
            printf("La Opcion Seleccionada es Erronia intente nuevamente");
        }
 
        getch();
    }while(ban!=1);
    getch();
} 

Esto era lo que estaba pidiendo que hicieras para poder leer tu código porque sino es realmente imposible saber hasta donde llega cada llave...

Deberías usar funciones y usar variables locales. Las variables globales hacen a los programas inconsistentes... Para algo existen los parámetros a funciones. Además si te das cuenta:

• Las líneas 55y 57 son lo mismo. Si entra en el primer <if> obviamente entrará en el segundo también.
• No sé cuál es la utilidad de la variable <ban>.
• La línea 66 no es necesaria ya que puedes hacer el <switch> del 1 al 9 y un caso <default> para cualquier otro caso.
• No utilices números mágicos (es decir, número literales como para el tamaño de la matriz o los bucles for). Es mejor crear unas constantes por ejemplo así:

#define TAM_COLS 3
#define TAM_FILAS 3 

• En vez de inicializar toda la matriz a 5 (que entiendo que es un número al azar) sería mejor inicializarla a 0 y usar el 1 para el primer jugador y el 2 para el segundo.
• Cada <case> es prácticamente igual al resto y ocupa 15 líneas. Agrupar código en una función te ahorrará bastante.

---

Yo haría lo siguiente: inicializar el tablero a 0, usar la variable <jugador> con valor {1,2} para determinar el jugador en cada momento, la variable <modo> con valor {1,2} para determinar 2 jugadores o 1 jugador vs máquina, respectivamente; y la variable <ganador> con valor {0,1,2} para representar ningún ganador, el primer jugador gana o el segundo jugador gana, respectivamente.

El programa general sería algo así:

// librerias
 
#define TAM_FILA 3
#define TAM_COL 3
 
// prototipos de funciones
// es mejor poner los prototipos antes del main y las funciones despues del main. Tambien se pueden poner las funciones completas antes del main
 
int main(){ // la funcion main es de tipo int. Es mejor ponerlo siempre
    int tablero[TAM_FILA][TAM_COL]; // tablero del juego
    int jugador = 1; // indica el jugador actual (por defecto el 1). valores = {1,2}
    int modo; // indica el modo de juego. valores = {1,2}
    int ganador = 0; // indica el ganador. valores = {0,1,2}
 
    inicializarTablero(tablero, 0);
 
    modo = elegirModo();
 
    while(!ganador && !tableroCompleto(tablero)){
        posicion = elegirPosicion(tablero, jugador, modo);
        actualizarTablero(tablero, jugador, posicion);
        ganador = comprobarGanador(tablero);
        jugador = (jugador + 1) % jugador; // intercambia el jugador de 1 a 2 y de 2 a 1
    }
 
    if(ganador)
        printf("Jugador %d gana!!", ganador);
    else
        printf("Empate...");
} 

Un código limpio, corto y sencillo... que con leer el <main> ya sabes lo que hace el programa. Si luego quieres ver cómo funciona una parte específica o quieres cambiar alguna parte, sólo tienes que ir a la función correspondiente.

Con esto claro puedes hacer una función como esta para que un jugador elija una posición VÁLIDA del tablero:

// como la variable tablero deberia ser declarada dentro del main, tendras que pasarla como parametro:
int elegirPosicion(int tablero[][TAM_COLS], int jugador, int modo){
    do{
        if(jugador == 2 && modo == 2) // si le toca a la maquina...
            posicion = 1 + rand() % (TAM_FILA * TAM_COL); // calcula una posicion aleatoria
        else{
            printf("Elige una posicion valida [%d, %d]: ", 1, TAM_FILA * TAM_COL);
            scanf("%d", posicion);
        }
        int fila = (posicion - 1) / TAM_COL; // calculas la fila segun la posicion
        int col = (posicion - 1) % TAM_COL; // calculas la columna segun la posicion
    }  while(fila >= TAM_FILA || col >= TAM_COL || tablero[fila][col]); // la tercera expresion solo funciona si inicializas la matriz a 0 como dije antes
    return posicion;
} 

El resto de funciones te las dejo a ti que yo creo que con esto ya te he hecho bastante. Te dejo como guía lo que debería hacer cada función:

// Poner todas las casillas del tablero con el valor <valor>
void inicializarTablero(int tablero[][TAM_COL], int valor);
 
// Mostrar los modos, hacer un filtro para que el modo sea valido y devolverlo cuando lo sea
int elegirModo();
 
// En la funcion <elegirPosicion(...) ya hemos comprobado que la casilla no este ocupada por lo que aqui
// solo tienes que calcular la fila y columna correspondiente y asignarle el valor <jugador>
void actualizarTablero(int tablero[][TAM_COL], int jugador, int posicion);
 
// Recorrer todo el tablero mientras no encuentres un 0 (valor por defecto de las casillas)
// Si encuentras un 0 devuelves el 0 y si no devuelves un numero distinto de 0 (la opcion habitual es 1 para asemejarlo a un true/false).
int tableroCompleto(tablero);
 
// Recorrer todo el tablero. Devolver el numero del jugador que ha ganado y si ninguno ha ganado, devolver un 0.
int comprobarGanador(tablero)

Gracias por responder y ayudarme, lo que no mencione es que el programa debe de ser asi porque yo algo parecido estuve haciendo asi pero el profesor lo quiere como lo mostre

Si de verdad me estás diciendo que tu profesor no te deja aplicar ninguno de los consejos y que por ende te está enseñando/obligando a no usar constantes, usar variables globales, repetir código, escribir código innecesario y no organizarlo en funciones... Siento decirte que tienes un pésimo profesor.

Pero bueno, tu duda era cómo generar un valor aleatorio para la máquina y en la función <elegirPosicion()> te he mostrado cómo hacerlo. Así que no sé si tienes alguna duda más.

si mas o menos me di una idea gracias por responder, el profesor piensa que copiamos del internet pero solamente hacemos el de pasar codigo pero ya vez.