3. [Game] Simon en C++
Este sitio utiliza cookies propias y de terceros. Si continúa navegando consideramos que acepta el uso de cookies. OK Más Información.
« anterior próximo »
Páginas: [1]   Ir Abajo

[Game] Simon en C++

  • 0 Respuestas
  • 3509 Vistas

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado Jhonjhon_123

  • *
  • Underc0der
  • Mensajes: 150
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
    • Jhonjhon_123's Software In Developed

[Game] Simon en C++

« en: Febrero 23, 2010, 07:40:31 pm »
Aqui les dejo un pequeño juego en C++ que ize hace un tiempo...

Es el conocido SIMON.

Se juega con las teclas:
                ___ ___
               |_7_|_8_|     7- azul    8- rojo
               |_4_|_5_|     4- verde  5- amarillo 

Se podria perfeccionar mucho...

- Deje a medias lo del orden aleatorio para las jugadas y el almacenamiento de records...
Esto sera para version nº2 :)

Aqui los sources:

simon.cpp (archivo principal, contiene la main())
Código: C++
  1. #include <stdio.h>
  2. #include <iostream>
  3. #include<winbgim.h>
  4. #include<windows.h>
  5. #include<conio.h>
  6. #include<time.h>
  7.  
  8. #include "presentacion.h"
  9. #include "tablero.h"
  10. using namespace std;
  11.  
  12.  
  13. class jugadas:public tablero
  14. {
  15. public:
  16.       jugadas():tablero()
  17.       {
  18.        
  19.       }
  20.       void juego();
  21.       void a1();
  22.       void r2();
  23.       void v3();
  24.       void z4();
  25.       void perdiste();
  26.       int var1;
  27.       int avance;
  28.       int var3;
  29.       void teclado();
  30.       void inicializaAvance();
  31. private:
  32.              
  33. };
  34. void jugadas::perdiste()
  35. {
  36.      outtextxy(300,300,"Perdiste");
  37.      delay(8000);
  38.  }
  39. void jugadas::inicializaAvance()
  40. {
  41.     avance=0;
  42.  }
  43. void jugadas::a1()
  44. {
  45.      setcolor(CYAN);
  46.      rectangle(200,50,400,250);
  47.      int xBLUE1=201;
  48.      int yBLUE1=51;
  49.      int xBLUE2=399;
  50.      int yBLUE2=249;
  51.      int z1=0;
  52.      while(z1<99)
  53.      {
  54.                  setcolor(CYAN);
  55.                  rectangle(xBLUE1,yBLUE1,xBLUE2,yBLUE2);
  56.                  xBLUE1++;
  57.                  yBLUE1++;
  58.                  xBLUE2--;
  59.                  yBLUE2--;
  60.                  z1++;
  61.                  delay(10);
  62.      }
  63.       tablero::azul();/*
  64.       // la tecla 7 coincide con el azul, su codigo ascii es 55
  65.       // llamo a la variable ta (Tecla Azul)
  66.       int ta=(int)getch();
  67.       if (ta != 55)
  68.       {
  69.              perdiste();
  70.          }*/
  71. }
  72. void jugadas::r2()
  73. {
  74.      setcolor(CYAN);
  75.      rectangle(401,50,600,250);
  76.      int xRED1=401;
  77.      int yRED1=51;
  78.      int xRED2=599;
  79.      int yRED2=249;
  80.      int z3=0;
  81.      while(z3<100)
  82.      {
  83.                  setcolor(CYAN);
  84.                  rectangle(xRED1,yRED1,xRED2,yRED2);
  85.                  xRED1++;
  86.                  yRED1++;
  87.                  xRED2--;
  88.                  yRED2--;
  89.                  z3++;
  90.                  delay(10);
  91.      }
  92.      tablero::rojo();/*
  93.      // la tecla 8 coincide con el rojo, su codigo ascii es 56
  94.       // llamo a la variable tr (Tecla Roja)
  95.       int tr=(int)getch();
  96.       if (tr != 56)
  97.       {
  98.              perdiste();
  99.          }*/
  100. }
  101. void jugadas::v3()
  102. {
  103.      setcolor(CYAN);
  104.      rectangle(200,251,400,450);
  105.      int xGREEN1=201;
  106.      int yGREEN1=252;
  107.      int xGREEN2=399;
  108.      int yGREEN2=449;
  109.      int z2=0;
  110.      while(z2<99)
  111.      {
  112.                  setcolor(CYAN);
  113.                  rectangle(xGREEN1,yGREEN1,xGREEN2,yGREEN2);
  114.                  xGREEN1++;
  115.                  yGREEN1++;
  116.                  xGREEN2--;
  117.                  yGREEN2--;
  118.                  z2++;
  119.                  delay(10);
  120.      }
  121.      tablero::verde(); /*
  122.       // la tecla 4 coincide con el verde, su codigo ascii es 52
  123.       // llamo a la variable tv (Tecla Verde)
  124.       int tv=(int)getch();
  125.       if (tv != 52)
  126.       {
  127.              perdiste();
  128.          }*/
  129. }
  130. void jugadas::z4()
  131. {
  132.      setcolor(CYAN);
  133.      rectangle(401,251,601,450);
  134.      int xYELLOW1=402;
  135.      int yYELLOW1=252;
  136.      int xYELLOW2=600;
  137.      int yYELLOW2=449;
  138.      int z4=0;
  139.      while(z4<99)
  140.      {
  141.                  setcolor(CYAN);
  142.                  rectangle(xYELLOW1,yYELLOW1,xYELLOW2,yYELLOW2);
  143.                  xYELLOW1++;
  144.                  yYELLOW1++;
  145.                  xYELLOW2--;
  146.                  yYELLOW2--;
  147.                  z4++;
  148.                  delay(10);
  149.      }
  150.      tablero::amarillo();
  151.      /*
  152.       // la tecla 5 coincide con el amarillo, su codigo ascii es 53
  153.       // llamo a la variable tz porque llame al metodo z4
  154.       int tz=(int)getch();
  155.       if (tz != 53)
  156.       {
  157.              perdiste();
  158.          }*/
  159. }
  160.  
  161. void jugadas::juego()
  162. {
  163.      int jugadas[10]={4,2,3,4,1,2,3,4,1,2};
  164.      int jugadas1[10]={2,1,4,2,1,3,2,4,1,2};
  165.      int jugadas2[10]={4,1,4,2,1,4,3,2,3,1};
  166.     int a;
  167.     a=0;
  168.     //int alt=random();
  169.     int alt=0;
  170.     switch (alt)
  171.     {
  172.     case 0:
  173.                 for (var1=0; var1<=avance;)
  174.                 {
  175.                     if (jugadas[a]==1)
  176.                     {
  177.                        a1();
  178.                     }
  179.                     if (jugadas[a]==2)
  180.                     {
  181.                        r2();
  182.                     }
  183.                     if (jugadas[a]==3)
  184.                     {
  185.                        v3();
  186.                     }
  187.                     if (jugadas[a]==4)
  188.                     {
  189.                        z4();
  190.                     }
  191.                     var1++;
  192.                     a++;
  193.                 }
  194.                 teclado();
  195. }
  196. }
  197. void jugadas::teclado()
  198. {
  199. int jugadas[10]={4,2,3,4,1,2,3,4,1,2};
  200. int c;
  201. c=0;
  202. int contador;
  203. contador=0;
  204. fflush(stdin);
  205. for (contador=0; contador<=avance;)
  206.                      {
  207.                                  int tecla=(int)getch();
  208.                                  printf("%d",tecla);
  209.                                  if (tecla==55) // 7 ascii 55
  210.                                  {
  211.                                                 if (jugadas[c]!=1)
  212.                                                 {
  213.                                                  perdiste();
  214.                                                  }
  215.                                  }
  216.                                  if (tecla==56) // 8 ascii 56
  217.                                  {
  218.                                                 if (jugadas[c]!=2)
  219.                                                 {
  220.                                                  perdiste();
  221.                                                  }
  222.                                  }
  223.                                  if (tecla==52) // 4 ascii 52
  224.                                  {
  225.                                                 if (jugadas[c]!=3)
  226.                                                 {
  227.                                                 perdiste();
  228.                                                  }
  229.                                  }
  230.                                  if (tecla==53) // 5 ascii 53
  231.                                  {
  232.                                                 if (jugadas[c]!=4)
  233.                                                 {
  234.                                                  perdiste();
  235.                                                  }
  236.                                  }
  237.                                  contador++;
  238.                                  c++;
  239.                                  
  240.                        }
  241.                        avance++;
  242.                        juego();
  243.                        
  244. }
  245.  
  246.  
  247. int main()
  248. {
  249. srand(time (NULL));
  250. presentacion pantalla;
  251. pantalla.titulo();
  252. pantalla.persiana();
  253. tablero cuadros;
  254. cuadros.limpiar();
  255. cuadros.azul();
  256. cuadros.rojo();
  257. cuadros.verde();
  258. cuadros.amarillo();
  259. jugadas niveles;
  260. niveles.inicializaAvance();
  261. niveles.juego();
  262. }
  263.  

presentacion.h
Código: C++
  1. class presentacion
  2. {
  3.       public:
  4.              presentacion();
  5.              void persiana();
  6.              void titulo();
  7.       private:
  8.               int coordenadaXpantalla;
  9.               int coordenadaYpantalla;
  10.       };
  11. presentacion::presentacion()
  12. {
  13.       coordenadaXpantalla=800;
  14.       coordenadaYpantalla=600;
  15.       initwindow(coordenadaXpantalla,coordenadaYpantalla);
  16. }
  17. void presentacion::persiana()
  18. {
  19.      setcolor(BLUE);
  20.      int xBLUE=0;
  21.      int yBLUE=0;
  22.      int z4=0;
  23.      while(z4<100)
  24.      {
  25.                 while(xBLUE<coordenadaXpantalla)
  26.                 {
  27.                                 putpixel(xBLUE,yBLUE,BLUE);
  28.                                 xBLUE++;
  29.                 }
  30.      z4++;
  31.      yBLUE++;
  32.      xBLUE=0;
  33.      delay(5);
  34.      }
  35.      Beep(100,100);
  36.      setcolor(RED);
  37.      int xRED=0;
  38.      int yRED=100;
  39.      int z3=0;
  40.      while(z3<100)
  41.      {
  42.                 while(xRED<coordenadaXpantalla)
  43.                 {
  44.                                 putpixel(xRED,yRED,RED);
  45.                                 xRED++;
  46.                 }
  47.      z3++;
  48.      yRED++;
  49.      xRED=0;
  50.      delay(5);
  51.      }
  52.      Beep(200,100);
  53.      setcolor(GREEN);
  54.      int xGREEN=0;
  55.      int yGREEN=400;
  56.      int z2=0;
  57.      while(z2<100)
  58.      {
  59.                 while(xGREEN<coordenadaXpantalla)
  60.                 {
  61.                                 putpixel(xGREEN,yGREEN,GREEN);
  62.                                 xGREEN++;
  63.                 }
  64.      z2++;
  65.      yGREEN++;
  66.      xGREEN=0;
  67.      delay(5);
  68.      }
  69.      Beep(300,100);
  70.      setcolor(YELLOW);
  71.      int xYELLOW=0;
  72.      int yYELLOW=500;
  73.      int z1=0;
  74.      while(z1<coordenadaYpantalla)
  75.      {
  76.                 while(xYELLOW<coordenadaXpantalla)
  77.                 {
  78.                                 putpixel(xYELLOW,yYELLOW,YELLOW);
  79.                                 xYELLOW++;
  80.                 }
  81.      z1++;
  82.      yYELLOW++;
  83.      xYELLOW=0;
  84.      delay(5);
  85.      }
  86.      Beep(500,100);
  87.      settextstyle(9,0,3); //(estilo,forma,tamaño)
  88.      outtextxy(300,550,"Pulsa una tecla para continuar");
  89.      int continuar=(int)getch();
  90.      fflush(stdin);
  91. }
  92. void presentacion::titulo()
  93. {
  94.      // TEXTO DE SIMON
  95.      setcolor(WHITE);
  96.      line(470,230,790,230);
  97.      setcolor(CYAN);
  98.      line(50,230,450,230);
  99.      outtextxy(470,250,"Videojuego creado en C++ (using winbgim)");
  100.      outtextxy(470,270,"Code posteado en e-root.org");
  101.      outtextxy(470,290,"Por ---- Endif");
  102.      
  103.      setcolor(BLUE);
  104.      int auxr;
  105.      int auxr1=610;
  106.      int auxr2=320;
  107.      int auxr3=630;
  108.      int auxr4=340;
  109.      for (auxr=0; auxr<11; auxr++)
  110.      {
  111.          rectangle(auxr1,auxr2,auxr3,auxr4);
  112.          auxr1++;
  113.          auxr2++;
  114.          auxr3--;
  115.          auxr4--;
  116.      }
  117.      setcolor(RED);
  118.      int auxb;
  119.      int auxb1=631;
  120.      int auxb2=320;
  121.      int auxb3=651;
  122.      int auxb4=340;
  123.      for (auxb=0; auxb<11; auxb++)
  124.      {
  125.          rectangle(auxb1,auxb2,auxb3,auxb4);
  126.          auxb1++;
  127.          auxb2++;
  128.          auxb3--;
  129.          auxb4--;
  130.      }    
  131.      setcolor(GREEN);
  132.      int auxg;
  133.      int auxg1=610;
  134.      int auxg2=341;
  135.      int auxg3=630;
  136.      int auxg4=361;
  137.      for (auxg=0; auxg<11; auxg++)
  138.      {
  139.          rectangle(auxg1,auxg2,auxg3,auxg4);
  140.          auxg1++;
  141.          auxg2++;
  142.          auxg3--;
  143.          auxg4--;
  144.      }
  145.      setcolor(YELLOW);
  146.      int auxy;
  147.      int auxy1=631;
  148.      int auxy2=341;
  149.      int auxy3=651;
  150.      int auxy4=361;
  151.      for (auxy=0; auxy<11; auxy++)
  152.      {
  153.          rectangle(auxy1,auxy2,auxy3,auxy4);
  154.          auxy1++;
  155.          auxy2++;
  156.          auxy3--;
  157.          auxy4--;
  158.      }
  159.      setcolor(WHITE);
  160.      rectangle(610,320,651,361);
  161.      // LETRA S
  162.      setcolor(WHITE);
  163.      rectangle(50,250,170,270);
  164.      int s1=51;
  165.      int s2=251;
  166.      int s3=169;
  167.      int s4=269;
  168.      int s5;
  169.      for (s5=0; s5<10; s5++)
  170.      {
  171.          rectangle(s1,s2,s3,s4);
  172.          s1++;
  173.          s2++;
  174.          s3--;
  175.          s4--;
  176.      }
  177.      rectangle(50,270,70,300);
  178.      int s6=51;
  179.      int s7=271;
  180.      int s8=69;
  181.      int s9=299;
  182.      int s10;
  183.      for (s10=0; s10<10; s10++)
  184.      {
  185.          rectangle(s6,s7,s8,s9);
  186.          s6++;
  187.          s7++;
  188.          s8--;
  189.          s9--;
  190.      }
  191.      rectangle(50,300,170,320);
  192.      int s11=51;
  193.      int s12=301;
  194.      int s13=169;
  195.      int s14=319;
  196.      int s15;
  197.      for (s15=0; s15<10; s15++)
  198.      {
  199.          rectangle(s11,s12,s13,s14);
  200.          s11++;
  201.          s12++;
  202.          s13--;
  203.          s14--;
  204.      }
  205.      rectangle(150,320,170,350);
  206.      int s16=151;
  207.      int s17=321;
  208.      int s18=169;
  209.      int s19=349;
  210.      int s20;
  211.      for (s20=0; s20<10; s20++)
  212.      {
  213.          rectangle(s16,s17,s18,s19);
  214.          s16++;
  215.          s17++;
  216.          s18--;
  217.          s19--;
  218.      }
  219.      rectangle(50,350,170,370);
  220.      int s25=51;
  221.      int s21=351;
  222.      int s22=169;
  223.      int s23=369;
  224.      int s24;
  225.      for (s24=0; s24<10; s24++)
  226.      {
  227.          rectangle(s25,s21,s22,s23);
  228.          s25++;
  229.          s21++;
  230.          s22--;
  231.          s23--;
  232.      }
  233.      // letra I
  234.      setcolor(WHITE);
  235.      rectangle(180,250,200,370);
  236.      int i1=181;
  237.      int i2=251;
  238.      int i3=199;
  239.      int i4=369;
  240.      int i5;
  241.      for (i5=0; i5<10; i5++)
  242.      {
  243.          rectangle(i1,i2,i3,i4);
  244.          i1++;
  245.          i2++;
  246.          i3--;
  247.          i4--;
  248.      }
  249.      // letra M
  250.      setcolor(WHITE);
  251.      rectangle(210,250,230,370);
  252.      int i6=211;
  253.      int i7=251;
  254.      int i8=229;
  255.      int i9=369;
  256.      int i10;
  257.      for (i10=0; i10<10; i10++)
  258.      {
  259.          rectangle(i6,i7,i8,i9);
  260.          i6++;
  261.          i7++;
  262.          i8--;
  263.          i9--;
  264.      }
  265.      rectangle(250,250,270,370);
  266.      int i11=251;
  267.      int i12=251;
  268.      int i13=269;
  269.      int i14=369;
  270.      int i15;
  271.      for (i15=0; i15<10; i15++)
  272.      {
  273.          rectangle(i11,i12,i13,i14);
  274.          i11++;
  275.          i12++;
  276.          i13--;
  277.          i14--;
  278.      }
  279.      rectangle(290,250,310,370);
  280.      int i16=291;
  281.      int i17=251;
  282.      int i18=309;
  283.      int i19=369;
  284.      int i20;
  285.      for (i20=0; i20<10; i20++)
  286.      {
  287.          rectangle(i16,i17,i18,i19);
  288.          i16++;
  289.          i17++;
  290.          i18--;
  291.          i19--;
  292.      }
  293.      rectangle(210,250,310,270);
  294.      int i21=211;
  295.      int i22=251;
  296.      int i23=309;
  297.      int i24=269;
  298.      int i25;
  299.      for (i25=0; i25<10; i25++)
  300.      {
  301.          rectangle(i21,i22,i23,i24);
  302.          i21++;
  303.          i22++;
  304.          i23--;
  305.          i24--;
  306.      }
  307.      //LA O
  308.      setcolor(WHITE);
  309.      rectangle(320,250,380,370);
  310.      int o1=321;
  311.      int o2=251;
  312.      int o3=379;
  313.      int o4=369;
  314.      int o5;
  315.      for (o5=0; o5<20; o5++)
  316.      {
  317.          rectangle(o1,o2,o3,o4);
  318.          o1++;
  319.          o2++;
  320.          o3--;
  321.          o4--;
  322.      }
  323.      //la n
  324.      rectangle(390,250,410,370);
  325.      int n1=391;
  326.      int n2=251;
  327.      int n3=409;
  328.      int n4=369;
  329.      int n5;
  330.      for (n5=0; n5<10; n5++)
  331.      {
  332.          rectangle(n1,n2,n3,n4);
  333.          n1++;
  334.          n2++;
  335.          n3--;
  336.          n4--;
  337.      }
  338.     rectangle(430,250,450,370);
  339.      int n6=431;
  340.      int n7=251;
  341.      int n8=449;
  342.      int n9=369;
  343.      int n10;
  344.      for (n10=0; n10<10; n10++)
  345.      {
  346.          rectangle(n6,n7,n8,n9);
  347.          n6++;
  348.          n7++;
  349.          n8--;
  350.          n9--;
  351.      }
  352.      rectangle(390,250,450,270);
  353.      int n11=391;
  354.      int n12=251;
  355.      int n13=449;
  356.      int n14=269;
  357.      int n15;
  358.      for (n15=0; n15<10; n15++)
  359.      {
  360.          rectangle(n11,n12,n13,n14);
  361.          n11++;
  362.          n12++;
  363.          n13--;
  364.          n14--;
  365.      }
  366.  }
  367.  

tablero.h
Código: C++
  1. class tablero
  2. {
  3.       public:
  4.              tablero();
  5.              void azul();
  6.              void verde();
  7.              void rojo();
  8.              void amarillo();
  9.              void limpiar();
  10.       private:
  11.              
  12.       };
  13.      
  14. tablero::tablero()
  15. {
  16.                   int nada;
  17. }
  18.  
  19. void tablero::limpiar()
  20. {
  21. // limpiamos la presentacion
  22.      setcolor(BLACK);
  23.      int xlimp=0;
  24.      int ylimp=0;
  25.      int limp=0;
  26.      while(limp<600)
  27.      {
  28.                 while(xlimp<800)
  29.                 {
  30.                                 putpixel(xlimp,ylimp,BLACK);
  31.                                 xlimp++;
  32.                 }
  33.      limp++;
  34.      ylimp++;
  35.      xlimp=0;
  36.      delay(5);
  37.      }
  38. }
  39.  
  40. void tablero::azul()
  41. {
  42. // cuadro AZUL
  43.      setcolor(BLUE);
  44.      rectangle(200,50,400,250);
  45.      int xBLUE1=201;
  46.      int yBLUE1=51;
  47.      int xBLUE2=399;
  48.      int yBLUE2=249;
  49.      int z1=0;
  50.      while(z1<99)
  51.      {
  52.                  setcolor(BLUE);
  53.                  rectangle(xBLUE1,yBLUE1,xBLUE2,yBLUE2);
  54.                  xBLUE1++;
  55.                  yBLUE1++;
  56.                  xBLUE2--;
  57.                  yBLUE2--;
  58.                  z1++;
  59.                  delay(10);
  60.      }
  61. }
  62. void tablero::verde()
  63. {
  64. // cuadros VERDE
  65.      setcolor(GREEN);
  66.      rectangle(200,251,400,450);
  67.      int xGREEN1=201;
  68.      int yGREEN1=252;
  69.      int xGREEN2=399;
  70.      int yGREEN2=449;
  71.      int z2=0;
  72.      while(z2<99)
  73.      {
  74.                  setcolor(GREEN);
  75.                  rectangle(xGREEN1,yGREEN1,xGREEN2,yGREEN2);
  76.                  xGREEN1++;
  77.                  yGREEN1++;
  78.                  xGREEN2--;
  79.                  yGREEN2--;
  80.                  z2++;
  81.                  delay(10);
  82.      }
  83. }
  84.  
  85. void tablero::rojo()
  86. {
  87. // cuadros ROJO
  88.      setcolor(RED);
  89.      rectangle(401,50,600,250);
  90.      int xRED1=401;
  91.      int yRED1=51;
  92.      int xRED2=599;
  93.      int yRED2=249;
  94.      int z3=0;
  95.      while(z3<100)
  96.      {
  97.                  setcolor(RED);
  98.                  rectangle(xRED1,yRED1,xRED2,yRED2);
  99.                  xRED1++;
  100.                  yRED1++;
  101.                  xRED2--;
  102.                  yRED2--;
  103.                  z3++;
  104.                  delay(10);
  105.      }
  106. }
  107.  
  108. void tablero::amarillo()
  109. {    
  110. // cuadros AMARILLO
  111.      setcolor(YELLOW);
  112.      rectangle(401,251,601,450);
  113.      int xYELLOW1=402;
  114.      int yYELLOW1=252;
  115.      int xYELLOW2=600;
  116.      int yYELLOW2=449;
  117.      int z4=0;
  118.      while(z4<99)
  119.      {
  120.                  setcolor(YELLOW);
  121.                  rectangle(xYELLOW1,yYELLOW1,xYELLOW2,yYELLOW2);
  122.                  xYELLOW1++;
  123.                  yYELLOW1++;
  124.                  xYELLOW2--;
  125.                  yYELLOW2--;
  126.                  z4++;
  127.                  delay(10);
  128.      }
  129. }
  130.  

Si tienen algun problema me dicen!

Espero que les sirva de algo :P

Autor: Radón
« Última modificación: Enero 25, 2015, 08:48:09 pm por Expermicid »
En línea
Páginas: [1]   Ir Arriba
« anterior próximo »
 

¿Te gustó el post? COMPARTILO!