Como hago que este modulo sea mas eficiente???? C++

[afrocardo]

Buenas, como hago para que este módulo sea más eficiente?

CÓDIGO:

void carga_colores_sonidos_numeros(numerosypuntos n)
{
   //For para recorrer el vector
   for(int cont=0;cont<N;cont++)
   {

   if(n.al[cont]==0){
      textcolor(1);
      Beep(500,200);
   }
   if(n.al[cont]==1){
      textcolor(2);
      Beep(200,101);
   }
   if(n.al[cont]==2){
      textcolor(3);
      Beep(797,145);
   }
   if(n.al[cont]==3){
      textcolor(4);
      Beep(567,189);
   }
   if(n.al[cont]==4){
      textcolor(5);
      Beep(345,200);
   }
   if(n.al[cont]==5){
      textcolor(6);
      Beep(200,400);
   }
   if(n.al[cont]==6){
      textcolor(7);
      Beep(320,134);
   }
   if(n.al[cont]==7){
      textcolor(8);
      Beep(302,211);
   }
   if(n.al[cont]==8){
      textcolor(9);
      Beep(211,400);
   }
   if(n.al[cont]==9){
      textcolor(10);
      Beep(322,1000);
   }
   if(n.al[cont]==10){
      textcolor(11);
      Beep(233,544);
   }
   }//Fin for
}

[ivancea96]

Ni has explicado qué hace, ni para qué sirve, ni el nombre de la función es descriptivo.

Solo te puedo decir, que utilices un

Código (cpp) [Seleccionar] Expandir

switch(n.al[cont]){} en vez de esos if.

[afrocardo]

Te voy a enviar el programa completo.

Es todo lo que está en rojo
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
CÓDIGO:

//Adición de librerias

//Adición de sentencias de entrada y salida: cin y cout
#include <iostream>
//Adición de colores
#include <conio2.h>
//Manejo de ficheros
#include <fstream.h>
//Adición de sonidos al juego
#include <windows.h>
//Sentencia para evitar el std::cout y el std::cin
using namespace std;
//Definición de constantes
#define N 10
#define maxcar 20
#define M 30 //Para los puntos extra
#define maxronda 10

//Definición de tipo de dato de los siguientes vectores y de registros como:datos_jugador y numeroypuntos
typedef int aleatorios_juego[N];
typedef int numeros_introducidos[N];
typedef int fibonacci_puntos[N];
typedef char vector_nick[maxcar];
typedef struct{
   int codigo;
   vector_nick nombre;
   int partidas;
   int puntuacion_ultima;
   int puntuacion_max;
   int veces_final;
}datos_jugador;
typedef struct {
   aleatorios_juego al;
   fibonacci_puntos punt_fib;

}numerosypuntos;


//Prototipo modulos
void presentacion();
int menu();
numerosypuntos inicializar();
void mostrar_aleatorios_prueba(numerosypuntos  n);
void asteriscos();
datos_jugador introducir_datos();
void visualizar_datos(datos_jugador j);
void introducir_datos_fichero(datos_jugador j,ofstream & escritura_jugadores);
bool existencia_jugador_fichero (datos_jugador & j, ifstream & lectura_jugadores, int codigoint);
void jugar (datos_jugador & j,numerosypuntos n);
void carga_colores_sonidos_numeros(numerosypuntos n);
void instrucciones_juego(const numerosypuntos n);
void actualizar_fichero(ofstream & escritura_jugadores, datos_jugador j);
bool ronda(int numero_ronda, numerosypuntos n, datos_jugador & j, numeros_introducidos ni);
int calculo_fibonacci(int n);

//Main
int main() {

   //Declaracion variable jug perteneciente al registro datos_jugador
   datos_jugador jug;
   //Declaracion variable nu perteneciente al registro numerosypuntos
   numerosypuntos nu;
   //Declaracion de variable para el menu
   int opc;
   //Declaracion ficheros de lectura y escritura
   ifstream lectura_jugadores;
   ofstream escritura_jugadores;
   //Declaracion de variables para modulos
   int cod;
   int n_ronda;

   //Llamada al modulo presentación
   presentacion();
   //Se almacena el modulo menu en la variable opc para que pueda devolver una opcion el modulo menu
   opc=menu();

   //While para seleccionar las opciones del menu
   while(opc!=10){
      //Se le asigna el valor de 1 a la variable n_ronda
      n_ronda=1;
      switch(opc){
      case 1:
         //Muestra por pantalla que inicializara los aleatorios y los puntos para jugar
         cout<<"Inicializamos el conjunto de aleatorios de enteros y puntos para jugar."<<endl;
         //La llamada al módulo inicializar() se almacena en la variable nu,
         //ya que es una función y devuelve algo
         nu=inicializar();
         //Llamada al modulo asteriscos
         asteriscos();
         break;
      case 2:
         //Muestra por pantalla que introduzcas tus datos
         cout<<"Introduce tus datos :"<<endl;
         //La llamada al módulo introducir_datos() se almacena en la variable jug,
         //ya que es una función y devuelve algo
         jug=introducir_datos();
         //Llamada al modulo asteriscos
         asteriscos();
         break;
      case 3:
         //Muestra por pantalla que se van a comprobar los aleatorios generados
         cout<<"Comprobaremos los aleatorios generados."<<endl;
         //Llamada al módulo mostrar_aleatorios_prueba
         //Se le pasa la variable nu,ya que es un procedimiento.La variable nu esta en el programa principal
         mostrar_aleatorios_prueba(nu);
         //Llamada al modulo asteriscos
         asteriscos();
         break;
      case 4:
         //Muestra por pantalla que van a mostrar los datos introducidos del jugador
         cout<<"Estos son los datos del jugador :"<<endl;
         //Llamada al módulo asteriscos
         asteriscos();
         //Llamada al módulo visualizar_datos
         //Se le pasa la variable jug,ya que es un procedimiento.La variable jug esta en el programa principal
         visualizar_datos(jug);
         //Llamada al modulo asteriscos
         asteriscos();
         break;
      case 5:
         //Muestra por pantalla que se van a introducir los datos del jugador en el fichero
         cout<<"Introducimos los datos del jugador en el fichero ""simon.txt"""<<endl;
         //Llamada al módulo introducir_datos_fichero
         //Se le pasa la variable jug y el fichero de escrituta:escritura_jugadores para añadir los datos de  los jugadores en el fichero,
         //ya que es un procedimiento.La variable jug esta en el programa principal
         introducir_datos_fichero(jug,escritura_jugadores);
         //Muestra por pantalla que los datos han sido introducidos correctamente
         cout<<"Los datos han sido introducidos al fichero satisfactoriamente ."<<endl;
         break;
      case 6:
         //Muestra por pantalla que se comprobará si el jugador introducido esta en el fichero
         cout<<"Comprobamos si el jugador introducido está disponible en el fichero :"<<endl;
         //Muestra por pantalla que introduzcas el codigo del jugador para buscarlo en el fichero
         cout<<"Introduce codigo del jugador para localizar :"<<endl;
         //Se introduce por teclado el codigo del jugador a buscar
         cin>>cod;

         //If para comprobar si el jugador existe en el fichero,después de haber introducido el codigo del jugador
         if(existencia_jugador_fichero (jug,lectura_jugadores,cod))
         {
            cout<<"El jugador con codigo:  "<<cod<<"  existe en el fichero."<<endl;

         }
         else{
            cout<<"El jugador con codigo:   "<<cod<<"  no existia y lo hemos creado."<<endl;
         }
         //Llamada al modulo asterisco
         asteriscos();
         break;
      case 7:
         //Llamada al módulo instrucciones_juego
         //Se le pasa la variable nu,ya que es un procedimiento.La variable nu esta en el programa principal
         instrucciones_juego(nu);
         //Llamada al modulo asterisco
         asteriscos();
         break;
      case 8:
         //Se añade el color azul claro
         textcolor(LIGHTBLUE);
         //Muestra por pantalla un mensaje de bienvenida
         cout<<"¡¡BIENVENIDO/A AL JUEGO DEL SIMON:   "<<   jug.nombre  <<endl;
         //Se añade el tiempo de retraso
         Sleep(2000);
         //Llamaada al módulo jugar
         //Se le pasa la variable jug y la variable nu,ya que es un procedimiento.La variable jug y nu estan en el programa principal
         jugar(jug,nu);
         break;
      case 9:
         //Llamada al módulo actualizar_fichero
         //Se le pasa el fichero escritura_jugadores y la variable jug ,ya que es un procedimiento.La variable jug y el fichero estan en el programa principal
         actualizar_fichero(escritura_jugadores,jug);
         //Llamada al modulo asterisco
         asteriscos();
         break;

      }
      //Denuevo se vuelve a llamar al modulo menu junto a su variable de almacenamiento opc, ya que se debe volver a mostrar el menu para poder elegir otra opcion
      opc=menu();
   }
   //Al salir del juego
   //Muestra por pantalla un mensaje de que viciarse es malo
   cout<<"Eso, ¡sin viciarse que eso es malo!"<<endl;
   system("PAUSE");

   return 0;
}
//Definición de modulos
//Modulo 1.Presentación : Mostrara unos mensajes de bienvendida al juego
void presentacion()
{
   //Se añade el color amarillo a los mensajes de bienvenida
   textcolor(YELLOW);
   //Muestra por pantalla los mensajes de bienvenida
   cout<<"***********************************************************************************************"<<endl;
   cout<<"******************************  BIENVENIDO/A LA PRACTICA FINAL DE FP       ********************"<<endl;
   cout<<"******************************            CURSO 2015/16                    ********************"<<endl;
   cout<<"******************************          JUEGO 'SUPER SIMON'                ********************"<<endl;
   cout<<"******************************    REALIZADO POR: LEANDRO & TOMAS & RICARDO ********************"<<endl;
   cout<<"***********************************************************************************************"<<endl;
   //Banda sonora al iniciar el juego
   Beep (330,100);Sleep(100);
   Beep (330,100);Sleep(300);
   Beep (330,100);Sleep(300);
   Beep (262,100);Sleep(100);
   Beep (330,100);Sleep(300);
   Beep (392,100);Sleep(700);
   Beep (196,100);Sleep(700);

}
//Modulo 2.Menu: Mostrara las opcione a elegir
int menu()
{
   //Se añade el color blanco a las opciones a elegir
   textcolor(WHITE);
   //Declaracion de variable opcion
   int opcion;
   //Muestra por pantalla las opciones a elegir
   cout<<"1.INICIALIZAR NUMEROS ALEATORIOS Y PUNTOS."<<endl;
   cout<<"2.INICIALIZAR JUGADOR NUEVO."<<endl;
   cout<<"3.VISUALIZAR NUMEROS ALEATORIOS(SOLO PARA PRUEBAS): BAJO CONTRASEÑA."<<endl;
   cout<<"4.VISUALIZAR LOS DATOS DEL JUGADOR."<<endl;
   cout<<"5.INTRODUCIR JUGADOR EN EL FICHERO."<<endl;
   cout<<"6.COMPROBACION DE LA EXISTENCIA DEL JUGADOR EN EL FICHERO."<<endl;
   cout<<"7.INSTRUCCIONES DEL JUEGO (MÓDULO EXTRA AÑADIDO POR NOSOTROS)"<<endl;
   cout<<"8.JUGAR AL JUEGO."<<endl;
   cout<<"9.ACTUALIZAR DATOS DEL FICHERO DE JUGADORES."<<endl;
   cout<<"10.SALIR DEL PROGRAMA."<<endl;
   //Muestra por pantalla que introduzcas un numero del 1 al 10
   cout<<"Introduce opcion de 1 a 10 :"<<endl;
   //Se introduce la opcion deseada
   cin>>opcion;
   //While para controlar que el que haya elejido la opcion la haya introducido correctamente
   //Sino se ha introducido correctamente mostrara un mensaje de error
   while(opcion<1 || opcion>10)
   {
      //Muestra un mensaje de error y que vuelvas a elegir una opcion
      cout<<"Error, opción introducida no es valida. Introduce una opcion de 1 a 9 :"<<endl;
      //Se introduce la opcion deseada
      cin>>opcion;
   }
   //El modulo devuelve una opcion.Es decir, la opción elegida
   return opcion;
}

//Modulo 3.Inicializar: (Inicialiazará los datos del jugador ,si es nuevo)
//Calculará el Fibonacci y mostrará un mensaje de que se an inicializado correctamente los aleatorio y los puntos
numerosypuntos inicializar()
{
   //Declaración de variable n del registro numerosypuntos
   numerosypuntos n;
   //Inicialización de la semilla aleatoria
   srand(time(NULL));
   //For para ir recorriendo el vector
   for(int i=0;i<N;i++)
   {
      //Fórmula para ir calculando numeros aleatorios entres 0 y 10
      n.al=rand()%11;
   }
   //For para ir recorriendo el vector
   for(int i=0;i<N;i++)
   {
      //Fórmula para calcular el Fibonacci
      n.punt_fib=calculo_fibonacci(i);

   }
   //Muestra por pantalla un mensaje de que los aleatorios y los puntos han sido inicializados satisfactoriamente
   cout<<"Aleatorios y puntos inicializados satisfactoriamente:)"<<endl;
   //El módulo devuelve los numeros aleatorios y los puntos Fibonacci*
   return n;
}
//Modulo 3.Mostrar_aleatorios_prueba: Mostrará los números aleatorios del vector del juego(sólo el adminustrador del juego puede verlos)
//Habrá que introducir una clave para ver los aleatorios
void mostrar_aleatorios_prueba(const numerosypuntos n)
{
   //Contraseña: 12345
   //Declaracion de variable contraseña
   int contrasena;
   //Muestra por pantalla un mensaje de que mostrará los aleatorios,pero si antes has introducido la contraseña
   cout<<"Mostraremos el vector con todos los aleatorios, pero antes, INTRODUZCA SU CONTRASEÑA :"<<endl;
   //Se introduce la contraseña que debe ser correcta para poder ver los aleatorios
   cin>>contrasena;
   //While para controlar que el que haya introducido la contraseña la haya introducido correctamente
   //Sino se ha introducido correctamente mostrara un mensaje de error
   while(contrasena!=12345){
      cout<<"Error, contraseña incorrecta. Introduzca de nuevo la contraseña :"<<endl;
      //Se vuelve a introducir la contraseña que debe ser correcta para poder ver los aleatorios
      cin>>contrasena;
   }
   //Muestra por pantalla un mensaje para mostrar los aleatorios del vector
   cout<<"Aquí están los aleatorios generados en el vector :"<<endl;
   //For para recorrer el vector
   for(int i=0;i<N;i++)
   {
      //Muestra por pantalla un mensaje para mostrar los aleatorios(n.al) en función de la posición i del vector
      cout<<"El numero :   "<< i <<  "    es     :"<<    n.al<<endl;
   }
   //For para recorrer el vector
   for(int i=0;i<N;i++)
   {
      //Muestra por pantalla un mensaje para los numeros Fibonacci(n.punt_fib) en función de la posición i del vector
      cout<<"En la posicion fibonacci :  "<<i<<"   se encuentrar los puntos:   "<<n.punt_fib<<endl;
   }
}
//Modulo 4.Asteriscos: Mostrará una línea de asteriscos
void asteriscos()
{
   cout<<"**************************************************************************************"<<endl;
}
//Modulo 5.Calculo_fibonacci: Calculará la sucesión Fibonacci
int calculo_fibonacci(int n)
{
   //Declaración de variable fib que será devuelta por el módulo
   int fib;
   //If para controlar que si el numero pasado n es 0 o 1 la variable Fibonacci valdrá 1
   //Sino se calculará el Fibonaccion con la fórmula de debajo del else
   if((n==0)||(n==1))
   {
      fib=1;
   }
   else{
      //No la entiendo
      fib=(calculo_fibonacci(n-2)+calculo_fibonacci(n-1));
   }
   //El módulo devuelve un entero que será el Fibonacci*
   return fib;

}
//Modulo 6.Introducir_datos: Mostrará los datos del jugador
datos_jugador introducir_datos(){
   //Declaración de variable j del registro datos_jugador
   datos_jugador j;
   //Muestra por pantalla un mensaje de que introduzcas el codigo del jugador a registrar
   cout<<"Introduce el codigo del jugador :"<<endl;
   //Se introduce el codigo
   cin>>j.codigo;
   //Muestra por pantalla un mensaje de que introduzcas el nombre del jugador a registrar
   cout<<"Introduce el nombre del jugador :"<<endl;
   //Se introduce el nombre
   cin>>j.nombre;
   //Incicializo las partidas,puntuacion ultima,puntiacion maxima y veces final a 0
   j.partidas=0;
   j.puntuacion_ultima=0;
   j.puntuacion_max=0;
   j.veces_final=0;
   //El módulo devuelve los datos del jugador, que serían los datos introducidos
   return j;
}
//Modulo 7.Visualizar_datos: Visualizará los datos del jugador
void visualizar_datos(const datos_jugador j)
{
   //Muestra por pantalla etsos mensajes que son los datos del jugador
   cout<<"El código del jugador es  :    "<< j.codigo<<endl;
   cout<<"EL nombre del jugador es  :    "<< j.nombre <<endl;
   cout<<"El jugador   :   "<< j.nombre  <<"    lleva   :"<< j.partidas << "   jugadas  ."<<endl;
   cout<<"El jugador   :   "<< j.nombre << "  consiguó un total de   :   "<<j.puntuacion_ultima << "    puntos la última vez que jugó. "<<endl;
   cout<<"El jugador   :   "<<j.nombre<< "   ha conseguido una puntuación maxima de :  "<<j.puntuacion_max<< "  puntos."<<endl;
   cout<<"El jugador   :   "<<j.nombre<< "   ha llegado al final del juego  :   "<<j.veces_final<<"  veces."<<endl;
}
//Módulo 8.Introducir_datos_fichero : Se almacenarán los datos en el fichero
void introducir_datos_fichero(datos_jugador j,ofstream & escritura_jugadores)
{
   //Muestra por pantalla etsos mensajes que son los datos del jugador
   cout<<"Vamos a guardar los datos del jugador en el fichero de texto : simon.txt."<<endl;
   //Se abre el fichero para escribir sobre él
   escritura_jugadores.open("simon.txt");
   //If para comprobar que si el fichero se ha abierto correctamente,se alamacenen los datos en el fichero
   //Si se abre mal mostrará un mensaje de error
   if(escritura_jugadores.fail())
   {
      cout<<"Error en la apertura del fichero simon.txt, lo sentimos."<<endl;
   }
   else
   {
      escritura_jugadores<<j.codigo<<endl;
      escritura_jugadores<<j.nombre<<endl;
      escritura_jugadores<<j.partidas<<endl;
      escritura_jugadores<<j.puntuacion_ultima<<endl;
      escritura_jugadores<< j.puntuacion_max <<endl;
      escritura_jugadores<< j.veces_final<<endl;


   }
   //Se cierra el fichero para que no se vuelva corrupto y para que se guarden los datos
   escritura_jugadores.close();
}
//Módulo 8.Existencia_jugador_fichero: Se verificará si los datos del jugador están en el fichero
bool existencia_jugador_fichero (datos_jugador & j, ifstream & lectura_jugadores, int codigoint)
{
   //Declaración de variable existe que será devuelta por el módulo, y está puesta a false
   bool existe=false;
   //Se abre el fichero para leer lo que hay dentro
   lectura_jugadores.open("simon.txt");
   //If para comprobar que si el fichero se ha abierto correctamente,se alamacenen los datos en el fichero
   //Si se abre mal mostrará un mensaje de error
   if(lectura_jugadores.fail())
   {
      cout<<"Lo sentimos, se ha producido un error en la lectura del fichero."<<endl;

   }
   else
   {
      //Sino hace una lectura anticipada con el codigo del jugador
      //y luego se leen los demas datos y se muestran por pantalla
      lectura_jugadores>>j.codigo;
      //While para controlar que si existe el jugador y no se ha llegado a fin de fichero
      //se mostraran por pantalla los datos del juagdor
      while(!lectura_jugadores.eof()&& existe==false)
      {
         //If para controlar que si el codigo del jugador es igual al codigo introducido
         //y existe, se mostrarán los datos del jugador
         if(codigoint==j.codigo)
         {
            existe=true;
         }
         lectura_jugadores>>j.nombre;
         lectura_jugadores>>j.partidas;
         lectura_jugadores>>j.puntuacion_max;
         lectura_jugadores>>j.puntuacion_ultima;
         lectura_jugadores>>j.veces_final;
         lectura_jugadores>>j.codigo;
      }
      //If para controlar que si el jugador no existe,tengas que meter los datos de nuevo
      if(existe==false)
      {
         //Llamada al modulo introducir_datos que se almacenará en la variable j del registro datos_jugador
         j=introducir_datos();
      }

      //Muestra por pantalla un mensaje de que se han leído los datos correctamente
      cout<<"Datos leídos correctamente..."<<endl;
      if(codigoint==j.codigo)
      {
         //Muestra por pantalla un mensaje de que el jugador tal si existe en el fichero
         cout<<"El jugador con codigo  :    "<< codigoint <<"   sí existe en el fichero."<<endl;
      }
      else
      {
         //Muestra por pantalla un mensaje de que el jugador con codigo tal no existe en el fichero
         cout<<"El jugador con codigo  :  "<< codigoint <<"   no existe en el fichero."<<endl;
      }
   }
   //Se cierra el fichero de lectura
   lectura_jugadores.close();
   //El módulo devuelve un booleano
   return existe;
}
//Módulo 9.Carga_colores_sonidos_numeros: Se cargarán los colores y sonidos por cada numero
void carga_colores_sonidos_numeros(numerosypuntos n)
{
   //For para recorrer el vector
   for(int cont=0;cont<N;cont++)
   {
   //If para aplicarle a cada numero aleatorio un color y un sonido distinto
   if(n.al[cont]==0){
      textcolor(1);
      Beep(500,200);
   }
   if(n.al[cont]==1){
      textcolor(2);
      Beep(200,101);
   }
   if(n.al[cont]==2){
      textcolor(3);
      Beep(797,145);
   }
   if(n.al[cont]==3){
      textcolor(4);
      Beep(567,189);
   }
   if(n.al[cont]==4){
      textcolor(5);
      Beep(345,200);
   }
   if(n.al[cont]==5){
      textcolor(6);
      Beep(200,400);
   }
   if(n.al[cont]==6){
      textcolor(7);
      Beep(320,134);
   }
   if(n.al[cont]==7){
      textcolor(8);
      Beep(302,211);
   }
   if(n.al[cont]==8){
      textcolor(9);
      Beep(211,400);
   }
   if(n.al[cont]==9){
      textcolor(10);
      Beep(322,1000);
   }
   if(n.al[cont]==10){
      textcolor(11);
      Beep(233,544);
   }
   }//Fin for
}

//Módulo 10.Jugar: Permitirá jugar el juego
void jugar (datos_jugador & j,numerosypuntos n)
{
   //Declaración de variable ni del registro numeros_introducidos
   numeros_introducidos ni;
   //Declaración de un contador y se inicializa a 1
   int num_ronda=1;
   //Declaración de variable booleana
   bool controlador=true;
   //While para comprobar que la variable controlador se cumpla y que el numero de ronda sea menor que el maximo de rondas
   while(controlador==true && num_ronda<maxronda)
   {

      //Se comprueba que la ronda sea la correcta y se aumente en una unidad
      controlador=ronda(num_ronda,n,j, ni);
      //Contador para pasar a la siguiente ronda
      num_ronda++;


   }
   //If para controlar que si la variable controlador se cumple
   //Se mostrará por pantalla que has pasado a la siguiente ronda,entre otras cosas.
   if(controlador==true)
   {
      cout<<"¡¡FELICIDADES!! Has logrado pasar la ronda 10."<<endl;
      cout<<"¡¡TE LLEVAS UN BONUS DE 30 PUNTOS POR ACABARTE EL JUEGO!!"<<endl;
            cout<<"Llevas una puntuacion total de   :  "<<j.puntuacion_ultima<<endl;
            j.veces_final++;
            j.partidas++;
            cout<<"ENHORABUENA, ¡¡¡ERES UN AUTÉNTICO GENIO!!! HAS CONSEGUIDO ACABARTE EL JUEGO."<<endl;
            cout<<"**********************¡¡¡FIN DEL JUEGO!!!*************************************"<<endl;
            Sleep(4000);
   }
   //Sino se cumple se mostrará un mensaje de que has perdido
   else
   {
      cout<<"Has perdido."<<endl;
      Sleep(4000);
      asteriscos();
   }
}
//Módulo 11.Ronda: Mostrará los números de cada ronda
bool ronda(int numero_ronda, numerosypuntos n, datos_jugador & j, numeros_introducidos ni)
{
   //Declaración de variable booleana controlador
   bool controlador=true;
   //Declaración variable contador y se inicializa a cero
   int cont=0;

   //For para recorrer el vector
   for(int i=0;i<numero_ronda;i++)
   {
   //Se limpia la pantalla
   clrscr();
   //Llamada al módulo carga_colores_sonidos_numeros
   carga_colores_sonidos_numeros(n);
   //Muestra por pantalla los numeros aleatorios
   cout<<n.al<<"  ";
   Sleep(1500);
   textcolor(WHITE);

   }
   cout<<"Esperamos 5 segundos a que memorices el contenido..."<<endl;
   Sleep(5000);//Espero 5 segundos
   clrscr();
   for(int i=0;i<numero_ronda;i++)
   {
   cout<<"Introduce los numeros que has visto :"<<endl;
   cin>>ni;
   }

   while(controlador==true && cont<numero_ronda)
   {
      if(n.al[cont]!=ni[cont])
         {
            controlador=false;
            j.partidas++;
            j.puntuacion_ultima=j.puntuacion_ultima-M/3;
            j.puntuacion_max=j.puntuacion_ultima;
            cout<<"Tu puntuacion es de :   "<<j.puntuacion_max<<endl;

         }
         else{
            controlador=true;
            j.puntuacion_ultima=n.punt_fib[cont];
            cout<<"¡¡FELICIDADES!! Has logrado pasar la ronda:  "<<cont+1<<endl;
            cout<<"Llevas una puntuacion total de   :  "<<j.puntuacion_ultima<<endl;

            cout<<"******************RONDA:  "<<cont+2<<"*************************************"<<endl;
            Sleep(4000);
         }
   cont++;
   }
   return controlador;
}


void instrucciones_juego(const numerosypuntos n)
{
   textcolor(LIGHTRED);
   cout<<"******************************************************************************************************************************"<<endl;
   cout<<"*********************************************INSTRUCCIONES DEL JUEGO**********************************************************"<<endl;
   cout<<"******************************************************************************************************************************"<<endl;
   textcolor(WHITE);
   cout<<"1.-Aparecera un numero en la pantalla."<<endl;
   cout<<"2.-Deberas memorizar el numero bien, tienes 5 segundos para hacerlo."<<endl;
   cout<<"3.-Despues, deberas introducir ese mismo numero correctamente, si no lo haces el juego terminará y perderas. Tu puntuación sera de -10."<<endl;
   cout<<"4.-Si aciertas, iras progresando en el juego, pasaras de ronda. Aparecera el numero que aparecio anteriormente, mas otro nuevo. Asi sera hasta que termines las 10 rondas o pierdas."<<endl;
   cout<<"5.-Los puntajes son los siguientes (RONDA 0 ES LA RONDA 1, RONDA 9 ES LA RONDA 10)"<<endl;
   for(int i=0;i<N;i++)
   {
      cout<<"Si superas la ronda:  "<<i<<"  te llevas:    "<<n.punt_fib<<"  puntos."<<endl;
   }
   cout<<"6.-Si consigues llegar a la mitad del juego (ronda 5), recibiras una bonificación extra de 15 puntos."<<endl;
   cout<<"7.-Si consigues acabar el juego (ronda 10), recibiras una bonificacion extra de 30 puntos. "<<endl;
   textcolor(LIGHTRED);
   cout<<"**************************************¡¡A JUGAR!!*****************************************************************************"<<endl;
   Beep (330,100);Sleep(100);
   Beep (330,100);Sleep(300);
   Beep (330,100);Sleep(300);
   Beep (262,100);Sleep(100);
   Beep (330,100);Sleep(300);
   Beep (392,100);Sleep(700);
   Beep (196,100);Sleep(700);
   textcolor(WHITE);

}

void actualizar_fichero(ofstream & escritura_jugadores, datos_jugador j)
{
   escritura_jugadores.open("simon.txt");
   if(escritura_jugadores.fail())
   {
      cout<<"Error en la apertura del fichero de escritura."<<endl;
   }
   else
   {
      escritura_jugadores<<j.codigo<<" ";
      escritura_jugadores<<j.nombre<<" ";
      escritura_jugadores<<j.partidas<<" ";
      escritura_jugadores<<j.puntuacion_ultima<<" ";
      escritura_jugadores<< j.puntuacion_max <<" ";
      escritura_jugadores<< j.veces_final<<endl;

   }
   escritura_jugadores.close();
   cout<<"Fichero actualizado correctamente."<<endl;
}

[Eternal Idol]

Código (c++) [Seleccionar] Expandir

typedef struct _combo
{
 unsigned char color;
 unsigned short freq;
 unsigned short duration;
}combo;

combo combinaciones[] =
{
 {1, 500, 200},
 {2, 200, 101}
   ...
};

Podes simplificar el codigo a un par de lineas de esa manera.

[engel lex]

En tal caso el código no sería más eficiente el código, sólo sería más corto o legible, pero a fines serían iguales

[Eternal Idol]

En tal caso el código no sería más eficiente el código, sólo sería más corto o legible, pero a fines serían iguales

Los compiladores modernos optimizan muy bien y es dificil hacer afirmaciones taxativas pero de la manera que le sugiero no se hace ninguna comparacion, se usa un indice a una tabla, asi que iguales no serian.