Red de conocimiento informático - Descarga de software - Utiliza C para escribir el juego de piedra, papel y tijera y programa la computadora para jugar con humanos.

Utiliza C para escribir el juego de piedra, papel y tijera y programa la computadora para jugar con humanos.

Está bien, la escritura es un poco redundante, jaja, soy un poco vago, la implementación de la función está escrita en el archivo de encabezado

// RSC.h

#ifndef _RSC_H_

#define _RSC_H_

#include lt;iostreamgt;

#include lt;stringgt;

#include lt;ctimegt;

usando std::cout;

usando std::cin;

usando std::endl;

///////////////////////////////////////////////// ////// /////////////////////////

#ifndef NULL

#define NULL 0

#endif // NULL

const int MAX_SIZE = 80;

//////////////// /////// //////////////////////////////////////////// /////////// /

// Opciones

typedef enum { ROCA, TIJERA, TELA, PANTALLA, AYUDA, SALIR } SeleccionarTipo;

// Resultado

typedef enum { GANAR, PERDER, EMPATE } Tipo de resultado;

//////////////////// /////////// /////////////////////////////////////// ///////

clase CRSCGame

{

público:

CRSCGame(void);

~CRSCGame(void);

// El marco principal del juego es el comienzo del cuerpo principal del juego

void Game(void);

// Muestra información de solicitud (esto es bastante simple) y se puede escribir como en línea

void Helps(void);

protected:

/ / Obtener información y procesar la elección del jugador

void GetChoice(void);

// Procesar las opciones seleccionadas por la computadora y el jugador, y generar resultados

void MsgProc(void);

// Genera información del juego, opciones seleccionadas, cuál es el resultado del juego

void Informations(SelectType comsLastChoice);

// Función de conversión, convierte las opciones seleccionadas en las cadenas correspondientes

std: :string ChoiceToStr(SelectType selectType);

private:

SelectType m_select; / Seleccionar

ResultadoT

ype m_result; // Resultado

int m_sum[3]; // Resultados estadísticos del juego (número de victorias y derrotas)

};

/// /// //////////////////////////////////////////////// ////// //////////////////

CRSCGame::CRSCGame()

: m_select(AYUDA), m_result(TIE)

{

for (int i=0; ilt; 3; i)

{// sum[0] es el número total de juegos jugados, suma[1] es el número de veces que el jugador gana, suma[2] es el número de sorteos

m_sum[i] = 0;

}

}

CRSCGame::~CRSCGame()

{

}

// público

void CRSCGame::Game()

{

mientras (verdadero)

{

intentar

{

GetChoice ();

}

captura (const char *szInfo)

{

std::cout lt; szInfo lt ;lt; std::endl;

continuar;

}

si (SALIR == m_select)

{

descanso

}

MsgProc()

}

return;

}

void CRSCGame::Helps()

{

std::cout lt;lt; Las configuraciones son las siguientes:\n" lt;lt; " Ingrese la selección correspondiente\n"

lt; lt; " r\t\t ROCK\n" lt; lt; " s\t\ t TIJERA\n" lt; lt; " c\t\t PAÑO\n"

lt; lt; "\n d\t\t DISPLAY\n" lt; lt; " h\t\ t AYUDA\n" lt; lt; " q\t\t SALIR\n";

retorno ;

}

// protegido

void CRSCGame::MsgProc ()

{

// La computadora selecciona aleatoriamente

SelectType comsSelect = SelectType(rand()3);

interruptor (m_select )

{

caso AYUDA:

Ayuda();

retorno;

descanso

caso PANTALLA:

{

std::cout lt; "Número de juegos jugados:" lt; m_sum[0] lt; ::cout lt;lt; "El jugador gana:" lt;lt; m_sum[1] lt;lt; " "

lt;lt; "Número de sorteos: " lt;lt; ] lt; lt; std::endl;

}

retorno;

descanso

predeterminado:

romper;

}

m_sum[0];

if (((ROCK==m_select)amp; amp; (SCISOR==comsSelect) )

|| ((SCISOR==m_select)amp;(CLOTH==comsSelect))

|| ((CLOTH==m_select)amp;amp;(ROCA = =comsSelect)))

{

m_result = WIN; // La ronda está ganada

m_sum[1];

}

else if (m_select == comsSelect)

{

m_result = TIE; // Empate

m_sum[2];

p>

}

else

{

m_result = LOSE; // El jugador perdió

}

Información(comsSelect);

retorno;

}

void CRSCGame::GetChoice()

{

char szSelectBuf[MAX_SIZE];

std::cout lt; "Ingrese (r/s/c/d/h/q):"

std::cin.getline(szSelectBuf, MAX_SIZE);

cambiar (szSelectBuf[0])

{

caso; 'd':

m_select = PANTALLA;

romper;

caso 'h':

m_select = AYUDA <

p> romper;

caso 'r':

m_select = ROCA

romper

caso 's':

p> p>

m_select = TIJERA;

romper;

caso 'c':

m_select = TELA

romper;

caso 'q':

m_select = SALIR

romper

predeterminado:

throw "¡Entrada desconocida! Inténtalo de nuevo por favor...";

break;

}

return

}

void CRSCGame::Informations(SelectType comsLastChoice)

{

std::cout lt;lt; "La elección de esta computadora:" lt;lt; comsLastChoice) lt;lt; std::endl;

std::cout lt;lt; "Esta vez tu elección:\t" lt;lt; ChoiceToStr(m_select) lt;lt; endl ;

cambiar (m_result)

{

caso GANAR:

{

std::cout lt ;lt; "¡Tú ganas!" lt;lt; std::endl;

}

descanso;

caso PERDER:

{

std:: cout lt; "¡Oh, pierdes!" ;

case TIE:

{

std::cout lt; "¡Oye, es un empate!" ;

}

romper

predeterminado:

romper

}

retorno ;

}

std::string CRSCGame::ChoiceToStr(SelectType selectType)

{

cambiar (selectType)

{

caso ROCA:

devolver "ROCA"

romper

p>

caso TIJERA:

devuelve "TIJETA";

rotura;

caso TELA:

devuelve "TELA" ;

romper;

predeterminado:

romper;

}

devolver "";

}

#endif // _RSC_H_

// Main_RSC.cpp

#include "RSC.h"

/////////////////////////////////////////////////// //// /////////////////////////

int main(int argc, char **argv)

{

CRSCGame theGame

srand(unsigned(time(NULL)));

theGame.Helps();

theGame();

return 0;

} // finaliza principal