Obtenga una puntuación alta y solicite urgentemente el código fuente del juego C++~ ~
# 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();
}
//-