Red de conocimiento informático - Consumibles informáticos - Obtenga una puntuación alta y solicite urgentemente el código fuente del juego C++~ ~

Obtenga una puntuación alta y solicite urgentemente el código fuente del juego C++~ ~

21 Juego de póquer

# incluir & ltctime & gt

//# incluir & lt;stdio & gt

# incluir & ltiostream & gt

//# include & lt; stdlib & gt

# include & ltconio.h & gt

Usar espacio de nombres std

//Definir clase de póquer

Juego de clase

{

Privado:

int ganar, perder, empatar, dinero;

int bet, playerturns, cputurns

Punto flotante player, cpu, card; //Aquí, CARD emitirá una advertencia al intercambiar datos con BET y se puede definir una evitación de tipo INT.

Marca de personaje;

Público:

juego();

Resultado no válido (jugador flotante, CPU flotante, apuesta int, int & amp dinero, intereses e intereses, int & ampwins, int & amp perder);

void wait(int milli

void símbolo();

void special(float&player,float&cpu);

void rule();

void pausa();

flotador aleatorio (Crece alto, crece bajo );

Impresión no válida (int ganar, int perder, int dibujar, int dinero);

Repetición no válida (personaje y bandera de amplificador);

p>

Golpe no válido (flotación y total);

Resultado no válido (jugador flotante, puntos de CPU, puntos de apuesta, puntos y dinero, intereses e intereses. empate, int y victoria, internacional y nacional. Pérdida);

p>

Apuestas nulas (intereses y comisiones; apuestas, intereses y comisiones.

dinero);

Transacción no válida (float&player,float&cpu,int&playerturns,int&cputurns);

Transacción no válida 2(float&player,float & ampcpu, int & ampplayerturns, int & ampcputurns);

void ask();

};

// -

//Función virtual completa

Juego: :juego()

{

gana = 0;

pierde = 0;

p>

empate = 0;

dinero = 0;

jugador = 0,0;

cpu = 0,0

apuesta = 0; turnos del jugador = 0;

giros de CPU = 0;

tarjeta = 0;

bandera = ' a

}

// -

void game::rules()

{

cout & lt& lt" \t * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * " & lt;& ltendl

cout & lt& lt" \ t * \ t \ tBienvenido a jugar a este juego de poker\ t \t \ t * " & lt& ltendl

cout & lt& lt" \ t * \ t \ t \Las reglas son las siguientes\ t \ t * " < & ltendl

cout & lt& lt" \ t * \ t \ t1: Tus cartas no pueden exceder de 5 cartas. \ t * " & lt& ltendl

cout & lt& lt" \t*\t\t 2: Puedes agregar apuestas. t \ t3: Acepta presionar y, \ t \ t \ t \ t \ * " & lt& ltendl

cout & lt& lt " \t * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * "& lt;& ltendl

cout & lt& lt"\t\t\t";

pause(); //Pausa aquí por unos segundos

p>

ask();

}

// -

juego nulo::ask()

{

cout & lt& ltendl & lt& ltendl

cout & lt& lt" \ t \ t \ t¿Quieres jugar a este juego? "& lt& ltendl

CIN & gt;& gt flag;

If((flag=='y')||(flag=='Y')) //Sentencia Ya sea para ingresar al juego.

{

cout & lt& lt" \ t \ t \Tendrás 100 yuanes para comenzar este juego" < & ltendl

Dinero = 100; / Establecer apuesta inicial

cout & lt& lt"\t\t\t";

pause();

}

else export(1);

Apuesta(apuesta, dinero);

deal(jugador, CPU, turnos de jugador, turnos de CPU); //Comenzar a procesar

}

// -

Apuestas (int & amp apuestas, intereses y comisiones. dinero)

{

int símbolo <; /p>

System("cls");

if (dinero& lt=0)

{

cout & lt& lt\ t \ t \No tienes apuestas, por favor cierra y comienza de nuevo. endl

Salir(1);

}

cout & lt& lt" \ t \ t \Tienes:"

cout & lt& lt" \ t \ t \Cuánto quieres apostar:";

Hacer{ //Determina si la apuesta ingresada es correcta.

Símbolo = 0;

CIN>>bet;

if((apuesta<0)&&(apuesta *-1<=dinero))

{

apuesta = apuesta *-1;

Romper;

}

si no((apuesta> ;0)&&(bet<=dinero))

break;

other

{

cout & lt& lt"Incorrecto entrada, vuelva a ingresar:";

sign = 1;

}

} while(sign = 1);

Dinero = dinero - apuesta;

}

// -

Juego no válido: :transaction(float&player,float&cpu,int&playerturns,int&cputurns)

{

flotante playercard1, playercard2, cpucard1, cpucard2

turnos de jugador = 2;

cputurns = 2

tarjeta de jugador; 1 = random(13, 1); //Comienza a dividir cartas con números aleatorios.

cout & lt& lt" \ n \ t \ t \Processing"

Esperando(350);

playercard2=random(13,1); /p>

Espera(150);

cpucard1=random(13,1);

Espera(350);

cpucard2= aleatorio( 13, 1);

if(tarjeta de jugador 1 & gt;=10)

{

tarjeta de jugador 1 = 0,5;

}

if(tarjeta de jugador 2 & gt;=10)

{

tarjeta de jugador2 = 0,5

}

if(tarjeta CPU 1 & gt;=10)

{

Tarjeta CPU 1 = 0,5;

}

if(tarjeta CPU 2>=10)

{

cpucard2 = 0.5

}

jugador = tarjeta de jugador 1+tarjeta de jugador 2;

CPU = Tarjeta CPU 1+Tarjeta CPU 2;

cout & lt& lt"Tu punto es:"

cout & lt& lt"Tus dos las tarjetas son";

cout & lt& lt"[" & lt;& ltTarjeta de jugador 1 & lt;& lt"]";

cout & lt& lt"[" & lt ;& ltplayercard2 & lt& lt"]";

cout & lt& ltendl

cout & lt& lt"\t\t\La computadora tiene un"

cout & lt& ltendl

cout & lt& lt"La tarjeta de la computadora es";

cout & lt& lt"[*]" & lt;& lt "[" & lt;& ltCPU card 1 & lt;& lt"]" & lt;& ltendl

deal2(player, cpu, playerturns, CPU turns //Llamar a la función de reparto

}<); /p>

// -

deal2(float & amp player, float & ampcpu, int & ampplayerturns, int & ampcputurns)

{

Do{

cout & lt& lt" \ t \ t \ t¿Quieres seguir pidiendo la tarjeta? "

CIN>>flag;

if(((flag == 'O')| |(flag == 'O')&& (playerturns & lt5)) / /Determina si eres un jugador avanzado.

{

Hacer

{

tarjeta = aleatorio(13,1);

if(tarjeta >10)

{

Tarjeta = 0.5;

}

cout & lt& lt" \ t \ t \下A la tarjeta es: "

cout & lt& lt" \ t \ t \ t¿Quieres esta tarjeta? (Ingresa p para continuar solicitando la tarjeta)"

CIN & gt ;& gt bandera;

if((flag=='p')||(flag=='P '))

{

el jugador gira++;

Jugador = jugador + carta;

cout & lt& lt\ t \ t \Tu puntuación actual es: "< & ltplayer & lt& ltendl

}

if(jugador gira & gt;=5)

{

cout & lt& lt\ t \ t \ t \Ya tienes cinco cartas, así que puedes' No pediré más tarjetas endlbreak;

}

} while(flag == ' p ');

}

. else if((flag = = ' y ')| |(flag = = ' y '))//Establece jugadores normales aquí

{

turnos de jugador++;

if(player>21)

{

cout<<"\t\t\Si rompes el banco, pierdes ";

Perdiste++;

Repetir(bandera);

}

si(el jugador cumple & gt; 5 )

{

cout & lt& lt\ t \ t \Ya has recibido cinco cartas, por lo que no puedes pedir más cartas endlBreak;

}

else if((el jugador gira & lt 6)& amp; & amp((flag=='y')||(flag=='Y '))

{

cout & lt& ltendl

hit(jugador);

}

}

} while((bandera == ' Y ')| |(bandera == ' Y '));

cout & lt& lt" \ t \ t \ t¿Quieres apostar más? "& lt& ltendl//Pregunta si necesitas hacer más apuestas.

CIN>& gtFlag;

if((flag=='y')||(flag= = 'Y '))

{

cout & lt& lt" \ t \ t \Ingrese la apuesta que desea agregar: "

Haga {;

CIN>& gtCard;

If(money==0) //Determina si se pueden realizar apuestas adicionales

{

< p. >cout & lt& lt\ t \ t \No has realizado una apuesta y el ordenador empieza a pedir cartas.

Pausa;

}

Si . ((Tarjeta)& gtMoney)

{

cout & lt& lt" \t\t\tTu apuesta no es suficiente.

"& lt& ltendl

cout & lt& lt" \ t \ t \Ingrese 0 en "

}

}mientras((tarjeta)& gt dinero

Apuesta = apuesta + tarjeta;

Dinero = tarjeta de dinero

}

for(; (cpu & lt16) ;& amp(cputurns & lt5);Cputurns++) //Equipo autorizado

{

cout & lt& ltendl

cout & lt& lt" \ t \ t \Tarjeta de solicitud de computadora" < & ltendl

hit(CPU);

if(CPU>21)

{

CPU = Tarjeta CPU;

Rotura;

}

}

cout & lt& ltendl

cout & lt& ltendl

cout & lt& lt" \ t \ t \El número de tarjetas en la computadora es:"

cout & lt& lt"Tu punto es:"

cout & lt& ltendl

if (((jugador & lt= 21); & amp(cpu & lt= 21)) ||(jugador gira = = 6) || (CPU gira Número = = 5))//Juicio especial

{

Especial (jugador, CPU);

}

Resultado (jugador, CPU) , apostar, dinero, empatar, ganar, perder);

Repetir(bandera);

Imprimir(ganar, perder, empatar, dinero);

cout & lt& ltendl

}

// -

Juego vacío::Golpe (flotación y amperaje total)//Función de tarjeta

{

Tarjeta flotante;

Tarjeta=aleatorio(13,1);

if(tarjeta>=10)

{

Tarjeta=0.5;

}

Total=Total+Tarjeta;

cout & lt& lt" \ t\t\La tarjeta lo que quieres es:"

cout & lt& lt" \t\t\tEl total de puntos es:"

}

// -

void game::pause()

{

cout & lt& lt"Presiona cualquier tecla para continuar"

getch ();

}

// -

juego nulo::wait(int mili)

{

clock_t start// Llame a la función a tiempo. H

inicio = reloj();

mientras((reloj()-inicio)<milli)

;

}

// -

Floatgame:: aleatorio (largo alto, largo bajo)//Obtiene un número aleatorio.

{

Flotante;

srand((unsigned) tiempo(vacío));

ran= rand()% (Alto -(Bajo-1))+Bajo;

Regresar (Ejecutar);

}

// -

Juego no válido: :Replay(personajes y banderas)

{

cout & lt& lt" \n \t\t\t¿Quieres continuar jugando este juego?:";

CIN>>Flag;

while((flag == ' y ') | | (flag == ' y '))//Establece el bucle del juego aquí.

{

Apuesta (apuesta, dinero);

reparto (jugador, CPU, turnos de jugador, turnos de CPU

}

Imprimir (ganar, perder, empatar, dinero);

}

// -

Voidgame:: imprimir (int gana, int perder, int dibujar, int dinero) // Genera el resultado.

{

cout & lt& lt" \ t \ t \ tWin:" < & lt; gana & lt& ltendl

cout & lt& lt\ t \ t \ t perder: "< & lt; perder & lt& ltendl

cout & lt& lt" t \ t \ t \ tand: "

cout & lt& lt" \ t \ t \Cantidad de dinero restante: " < & ltMoney& lt& ltendl

sign();

}

// -

resultado (jugador flotante, CPU flotante, apuesta int, moneda int y amp, interés e interés. empate, int y ampwins, int y amp pierden)

{

If( cpu== jugador) // Muestra el resultado

{

cout & lt& lt\ t \ t \Cuando los puntos son iguales, el crupier gana.

endl

draw++;

}

if(jugador & gt; 21)

{

cout & lt& lt" \ t \ t \Te has arruinado, vamos" < & ltendl

Perdido++;

}

Otros

{

Si (cpu & lt player)

{

cout & lt& lt\n\t\t\tFelicitaciones, ganas ";

Dinero = dinero + (apuesta* 2);

gana++;

}

}

if(CPU> ;21)

{

cout & lt& lt\ t \t\Vamos, banquero" < & ltendl

if(jugador & lt; 21)

{

cout & lt& lt"\n\t\t\tTú ganas";

gana++; + (apuesta * 2);

}

}

Otros

{

if(CPU & gt; jugador)

{

cout & lt& lt" \ t \ t \Perdiste" < & ltendl

perdiste++;

}

}

}

// -

void Juego::sign()

{

cout & lt& lt" \ n \ n \ n \ n \ t \ tEsta es la primera vez que escribo, por favor dame un consejo" < & ltendl

Salir(1) ;

}

// -

Especial (flotante &player,flotante&cpu)

/*Si las cinco cartas no superan las 21 y el oponente no recibe cinco cartas, es una victoria. Si ambos jugadores tienen cinco cartas pero no las tienen.

Si hay más de 21 puntos, gana el que tenga menos puntos.

*/

{

Si ((jugador & lt= 21);& amp(cpu & lt= 21);& amp(jugador cumple == 6)& amp;& amp(cputurns & lt5))

{

cout & lt& lt\n\t\t\tFelicitaciones, ganaste";

Dinero =dinero+( apuesta*2);

gana++;

}

if ((jugador & lt= 21); & amp(cpu & lt= 21);& amp(playerturns & lt6)& amp;& amp(cputurns==5))

{

cout & lt& lt" \ t \ t \Perdiste " < & ltendl

perdido++;

}

if ((jugador & lt= 21); & amp(cpu & lt= 21) ;& amp(jugador gira == 6)& amp;& amp(cputurns==5))

{

if(jugador & lt;cpu)

{

cout & lt& lt\n\t\t\tFelicitaciones, ganaste";

Dinero = dinero + (apuesta * 2);

gana++;

}

Otro

{

cout & lt& lt" \ t \ t \Perdiste " < & ltendl

Perdiste++ ;

}

}

Repetir (bandera);

}

// -

void main()

{

Cartas de juego;

reglas del mazo();

}

//-