API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 29th, 2015
161
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 17.44 KB | None | 0 0
raw download clone embed print report
  1. #include <iostream>
  2. #include "glut.h"
  3. #include <stdlib.h>
  4. #include <math.h>
  5. #include <time.h>
  6. #include <Windows.h>
  7. using namespace std;
  8.  
  9.  
  10. class kostka{
  11. public:
  12.     double wspx = 0;
  13.     double wspy = 0;
  14.     double wspz = 0;
  15.     float transx;
  16.     float transy;
  17.     float granicalewa;
  18.     float granicaprawa;
  19.  
  20. };
  21. int wskaznik = 0;
  22. int aktualnaSpadajacaFigura = 0;
  23. int liczbaFormDlaKlocka = 0;
  24. kostka *kloce = new kostka[wskaznik];
  25.  
  26. int flag = 0, forma = 1;
  27. bool ruch = true;
  28. float delta = 1;
  29. float granicadol = 90;
  30.  
  31. void Display()
  32. {
  33.     glClearColor(0.0, 0.0, 0.0, 0.0);
  34.  
  35.     glMatrixMode(GL_MODELVIEW);
  36.     glLoadIdentity();
  37.  
  38. }
  39.  
  40. float licznik = 0;
  41. GLuint listid;
  42. float kat = 0, ster = 0;
  43. float rozmiar = 10;
  44. float granlewo = 60, granprawo = 80;
  45.  
  46. bool czy_stop(kostka *figura, kostka* kloce, int wskaznik){
  47.     bool stoper = false;
  48.     double najnizszy = 10000000;
  49.     int najnizszyind;
  50.     bool kolizja = false;
  51.     float wspx1, wspy1, wspx2, wspy2;
  52.     for (int i = 0; i < sizeof(figura); i++){
  53.  
  54.         if (figura[i].wspy < najnizszy){
  55.             najnizszy = figura[i].wspy;
  56.             najnizszyind = i;
  57.         }
  58.  
  59.     }
  60.     //cout << "Wynik wynosi: " << abs(figura[najnizszyind].wspy - (figura[najnizszyind].wspy + figura[najnizszyind].transy)) << endl;
  61.     //cout << "Wynik wynosi: " << figura[najnizszyind].transy << endl;
  62.  
  63.     for (int i = 0; i < 4; i++){
  64.         for (int j = 0; j < wskaznik; j++){
  65.             wspx1 = figura[i].wspx + figura[i].transx;
  66.             wspy1 = figura[i].wspy - figura[i].transy;
  67.             wspx2 = kloce[j].wspx + kloce[j].transx;
  68.             wspy2 = kloce[j].wspy - kloce[j].transy;
  69.  
  70.             if (wspx1 == wspx2 && (wspy1 - 20) == wspy2) { kolizja = true; }
  71.             //cout << i<<":" <<j << ".Porownanie figur: " << wspx1 << ":" << wspx2<< endl;
  72.             //cout << i << ":" << j << ".Porownanie figur: " << wspy1 << ":" << wspy2 << endl;
  73.             //Sleep(100);
  74.  
  75.         }
  76.     }
  77.  
  78.     if (kolizja == true){
  79.  
  80.         cout << "Warunek kolizji" << endl;
  81.         stoper = true;
  82.  
  83.     }
  84.     else if (figura[najnizszyind].transy == granicadol){
  85.         cout << "Warunek spelniony" << endl;
  86.         stoper = true;
  87.     }
  88.  
  89.  
  90.  
  91.  
  92.  
  93.  
  94.  
  95.  
  96.  
  97.     return stoper;
  98. }
  99.  
  100. int kolizja_boczna(kostka* figura, kostka* kloce, float ster, float licznik){
  101.     int kolizja = 0;
  102.  
  103.     if (figura[0].granicalewa - ster >= granlewo){
  104.         cout << "Wystapienie kolizji z lewej strony" << endl;
  105.         kolizja = 1;
  106.     }
  107.     else if (figura[0].granicaprawa + ster > granprawo){
  108.         cout << "Wystapienie kolizji z prawej strony" << endl;
  109.         kolizja = 2;
  110.     }
  111.     else kolizja = 0;
  112.  
  113.  
  114.  
  115.     for (int i = 0; i < 4; i++){
  116.         for (int j = 0; j < wskaznik; j++){
  117.             //cout << "Roznica granic: " << figura[i].wspx << ":" << kloce[j].wspx + kloce[j].transx << endl;
  118.             if (figura[i].wspx + ster == kloce[j].wspx + kloce[j].transx && figura[i].wspy - licznik < (kloce[j].wspy - kloce[j].transy) + (rozmiar * 2)){
  119.                 cout << "Wystapienie kolizji z lewej strony" << endl;
  120.                 kolizja = 1;
  121.  
  122.             }
  123.  
  124.  
  125.         }
  126.  
  127.     }
  128.  
  129.  
  130.  
  131.  
  132.     return kolizja;
  133. }
  134.  
  135. void wyznacz_granx(kostka *figura){
  136.  
  137.     float lewo = 10000, prawo = -10000;
  138.  
  139.     for (int i = 0; i < 4; i++){
  140.  
  141.         if (figura[i].wspx < lewo){
  142.             lewo = figura[i].wspx;
  143.             figura[i].granicalewa = lewo;
  144.         }
  145.         if (figura[i].wspx > prawo){
  146.             prawo = figura[i].wspx;
  147.             figura[i].granicaprawa = prawo;
  148.         }
  149.  
  150.     }
  151.     for (int i = 0; i < 4; i++){
  152.  
  153.         figura[i].granicalewa = lewo;
  154.         figura[i].granicaprawa = prawo;
  155.  
  156.     }
  157.  
  158.  
  159. }
  160.  
  161. void rysujFigureI(kostka* figura, int forma){
  162.  
  163.     if (forma == 1){
  164.  
  165.         figura[0].wspx = 0;
  166.         figura[0].wspy = 60;
  167.         figura[1].wspx = 0;
  168.         figura[1].wspy = 40;
  169.         figura[2].wspx = 0;
  170.         figura[2].wspy = 20;
  171.         figura[3].wspx = 0;
  172.         figura[3].wspy = 0;
  173.     }
  174.     if (forma == 2){
  175.         figura[0].wspx = -20;
  176.         figura[0].wspy = 0;
  177.         figura[1].wspx = 0;
  178.         figura[1].wspy = 0;
  179.         figura[2].wspx = 20;
  180.         figura[2].wspy = 0;
  181.         figura[3].wspx = 40;
  182.         figura[3].wspy = 0;
  183.     }
  184.  
  185. }
  186.  
  187. // dlugas ---> S
  188. void rysujFigureZ(kostka* figura, int forma){
  189.  
  190.     if (forma == 1){
  191.  
  192.         figura[0].wspx = -20;
  193.         figura[0].wspy = 20;
  194.         figura[1].wspx = 0;
  195.         figura[1].wspy = 20;
  196.         figura[2].wspx = 0;
  197.         figura[2].wspy = 0;
  198.         figura[3].wspx = 20;
  199.         figura[3].wspy = 0;
  200.     }
  201.     if (forma == 2){
  202.         figura[0].wspx = 0;
  203.         figura[0].wspy = 40;
  204.         figura[1].wspx = 0;
  205.         figura[1].wspy = 20;
  206.         figura[2].wspx = -20;
  207.         figura[2].wspy = 20;
  208.         figura[3].wspx = -20;
  209.         figura[3].wspy = 0;
  210.     }
  211.  
  212. }
  213.  
  214. // dlugas ---> Z
  215. void rysujFigureS(kostka* figura, int forma){
  216.     if (forma == 1){
  217.  
  218.         figura[0].wspx = -20;
  219.         figura[0].wspy = 40;
  220.         figura[1].wspx = -20;
  221.         figura[1].wspy = 20;
  222.         figura[2].wspx = 0;
  223.         figura[2].wspy = 20;
  224.         figura[3].wspx = 0;
  225.         figura[3].wspy = 0;
  226.     }
  227.     if (forma == 2){
  228.         figura[0].wspx = -20;
  229.         figura[0].wspy = 0;
  230.         figura[1].wspx = 0;
  231.         figura[1].wspy = 0;
  232.         figura[2].wspx = 0;
  233.         figura[2].wspy = 20;
  234.         figura[3].wspx = 20;
  235.         figura[3].wspy = 20;
  236.     }
  237. }
  238.  
  239. void rysujFigureL(kostka* figura, int forma){
  240.     if (forma == 1){
  241.  
  242.         figura[0].wspx = -20;
  243.         figura[0].wspy = 0;
  244.         figura[1].wspx = -20;
  245.         figura[1].wspy = 20;
  246.         figura[2].wspx = 0;
  247.         figura[2].wspy = 20;
  248.         figura[3].wspx = 20;
  249.         figura[3].wspy = 20;
  250.     }
  251.     if (forma == 2){
  252.         figura[0].wspx = -20;
  253.         figura[0].wspy = 40;
  254.         figura[1].wspx = 0;
  255.         figura[1].wspy = 40;
  256.         figura[2].wspx = 0;
  257.         figura[2].wspy = 20;
  258.         figura[3].wspx = 0;
  259.         figura[3].wspy = 0;
  260.     }if (forma == 3){
  261.         figura[0].wspx = -20;
  262.         figura[0].wspy = 20;
  263.         figura[1].wspx = 0;
  264.         figura[1].wspy = 20;
  265.         figura[2].wspx = 20;
  266.         figura[2].wspy = 20;
  267.         figura[3].wspx = 20;
  268.         figura[3].wspy = 40;
  269.     }if (forma == 4){
  270.         figura[0].wspx = -20;
  271.         figura[0].wspy = 40;
  272.         figura[1].wspx = -20;
  273.         figura[1].wspy = 20;
  274.         figura[2].wspx = -20;
  275.         figura[2].wspy = 0;
  276.         figura[3].wspx = 0;
  277.         figura[3].wspy = 0;
  278.     }
  279. }
  280.  
  281. void rysujFigureJ(kostka* figura, int forma){
  282.  
  283.     if (forma == 1){
  284.  
  285.         figura[0].wspx = -20;
  286.         figura[0].wspy = 40;
  287.         figura[1].wspx = 0;
  288.         figura[1].wspy = 40;
  289.         figura[2].wspx = 20;
  290.         figura[2].wspy = 40;
  291.         figura[3].wspx = 20;
  292.         figura[3].wspy = 20;
  293.     }
  294.     if (forma == 2){
  295.         figura[0].wspx = 0;
  296.         figura[0].wspy = 40;
  297.         figura[1].wspx = 0;
  298.         figura[1].wspy = 20;
  299.         figura[2].wspx = 0;
  300.         figura[2].wspy = 0;
  301.         figura[3].wspx = -20;
  302.         figura[3].wspy = 0;
  303.     }if (forma == 3){
  304.         figura[0].wspx = 20;
  305.         figura[0].wspy = 0;
  306.         figura[1].wspx = 0;
  307.         figura[1].wspy = 0;
  308.         figura[2].wspx = -20;
  309.         figura[2].wspy = 0;
  310.         figura[3].wspx = -20;
  311.         figura[3].wspy = 20;
  312.     }if (forma == 4){
  313.         figura[0].wspx = -20;
  314.         figura[0].wspy = 0;
  315.         figura[1].wspx = -20;
  316.         figura[1].wspy = 20;
  317.         figura[2].wspx = -20;
  318.         figura[2].wspy = 40;
  319.         figura[3].wspx = 0;
  320.         figura[3].wspy = 40;
  321.     }
  322. }
  323.  
  324. void rysujFigureT(kostka* figura, int forma){
  325.  
  326.     if (forma == 1){
  327.  
  328.         figura[0].wspx = -20;
  329.         figura[0].wspy = 20;
  330.         figura[1].wspx = 0;
  331.         figura[1].wspy = 20;
  332.         figura[2].wspx = 20;
  333.         figura[2].wspy = 20;
  334.         figura[3].wspx = 0;
  335.         figura[3].wspy = 40;
  336.     }
  337.     if (forma == 2){
  338.         figura[0].wspx = 0;
  339.         figura[0].wspy = 40;
  340.         figura[1].wspx = 0;
  341.         figura[1].wspy = 20;
  342.         figura[2].wspx = 0;
  343.         figura[2].wspy = 0;
  344.         figura[3].wspx = 20;
  345.         figura[3].wspy = 20;
  346.     }if (forma == 3){
  347.         figura[0].wspx = -20;
  348.         figura[0].wspy = 20;
  349.         figura[1].wspx = 0;
  350.         figura[1].wspy = 20;
  351.         figura[2].wspx = 20;
  352.         figura[2].wspy = 20;
  353.         figura[3].wspx = 0;
  354.         figura[3].wspy = 0;
  355.     }if (forma == 4){
  356.         figura[0].wspx = 0;
  357.         figura[0].wspy = 40;
  358.         figura[1].wspx = 0;
  359.         figura[1].wspy = 20;
  360.         figura[2].wspx = 0;
  361.         figura[2].wspy = 0;
  362.         figura[3].wspx = -20;
  363.         figura[3].wspy = 20;
  364.     }
  365. }
  366.  
  367. void rysujFigureO(kostka* figura, int forma){
  368.     if (forma == 1){
  369.  
  370.         figura[0].wspx = -20;
  371.         figura[0].wspy = 20;
  372.         figura[1].wspx = -20;
  373.         figura[1].wspy = 00;
  374.         figura[2].wspx = 0;
  375.         figura[2].wspy = 20;
  376.         figura[3].wspx = 0;
  377.         figura[3].wspy = 0;
  378.     }
  379. }
  380.  
  381. int losujKtoraFigureWygenerowac(int min, int max, int licznik){
  382.     //cout << "LICZNIK: " << licznik << endl;
  383.     if (licznik == 0){
  384.         int x = min + rand() % max - min;
  385.         licznik++;
  386.         //cout << "LICZNIK IF: " << licznik << endl;
  387.         return x;
  388.     }
  389. }
  390.  
  391. void rysujOdpowiedniegoKlocka(bool mRuch, kostka *mFigura){
  392.     cout << "Wchodze do pyntli " << aktualnaSpadajacaFigura << endl;
  393.  
  394.     if (mRuch == true){
  395.         switch (aktualnaSpadajacaFigura){
  396.         case 0:
  397.             rysujFigureI(mFigura, forma);
  398.             break;
  399.         case 1:
  400.             rysujFigureS(mFigura, forma);
  401.             break;
  402.         case 2:
  403.             rysujFigureZ(mFigura, forma);
  404.             break;
  405.         case 3:
  406.             rysujFigureJ(mFigura, forma);
  407.             break;
  408.         case 4:
  409.             rysujFigureL(mFigura, forma);
  410.             break;
  411.         case 5:
  412.             rysujFigureT(mFigura, forma);
  413.             break;
  414.         case 6:
  415.             rysujFigureO(mFigura, forma);
  416.             break;
  417.         }
  418.     }
  419. }
  420.  
  421. void upKeyControl(){
  422.     // klocek I
  423.     if (aktualnaSpadajacaFigura == 0){
  424.         liczbaFormDlaKlocka = 2;
  425.         forma = forma + 1;
  426.         if (forma > liczbaFormDlaKlocka){
  427.             forma = 1;
  428.         }
  429.     }
  430.     // klocek Z
  431.     if (aktualnaSpadajacaFigura == 1){
  432.         liczbaFormDlaKlocka = 2;
  433.         forma = forma + 1;
  434.         if (forma > liczbaFormDlaKlocka){
  435.             forma = 1;
  436.         }
  437.     }
  438.     // klocek S
  439.     if (aktualnaSpadajacaFigura == 2){
  440.         liczbaFormDlaKlocka = 2;
  441.         forma = forma + 1;
  442.         if (forma > liczbaFormDlaKlocka){
  443.             forma = 1;
  444.         }
  445.     }
  446.     // klocek L
  447.     if (aktualnaSpadajacaFigura == 3){
  448.         liczbaFormDlaKlocka = 4;
  449.         forma = forma + 1;
  450.         if (forma > liczbaFormDlaKlocka){
  451.             forma = 1;
  452.         }
  453.     }
  454.     // klocek J
  455.     if (aktualnaSpadajacaFigura == 4){
  456.         liczbaFormDlaKlocka = 4;
  457.         forma = forma + 1;
  458.         if (forma > liczbaFormDlaKlocka){
  459.             forma = 1;
  460.         }
  461.     }// klocek T
  462.     if (aktualnaSpadajacaFigura == 5){
  463.         liczbaFormDlaKlocka = 4;
  464.         forma = forma + 1;
  465.         if (forma > liczbaFormDlaKlocka){
  466.             forma = 1;
  467.         }
  468.     }// klocek O
  469.     if (aktualnaSpadajacaFigura == 6){
  470.         liczbaFormDlaKlocka = 1;
  471.         forma = forma + 1;
  472.         if (forma > liczbaFormDlaKlocka){
  473.             forma = 1;
  474.         }
  475.     }
  476.     cout << "forma wynosi: " << forma << endl;
  477. }
  478.  
  479. void szescian(float x, float y){
  480.     glColor3f(1.0, 0.0, 0.0);
  481.  
  482.     glBegin(GL_LINE_LOOP);
  483.     glVertex3f(x + rozmiar, y + rozmiar, rozmiar);
  484.     glVertex3f(x - rozmiar, y + rozmiar, rozmiar);
  485.     glVertex3f(x - rozmiar, y - rozmiar, rozmiar);
  486.     glVertex3f(x + rozmiar, y - rozmiar, rozmiar);
  487.     glEnd();
  488.  
  489.     glBegin(GL_LINE_LOOP);
  490.     glVertex3f(x + rozmiar, y + rozmiar, -rozmiar);
  491.     glVertex3f(x - rozmiar, y + rozmiar, -rozmiar);
  492.     glVertex3f(x - rozmiar, y - rozmiar, -rozmiar);
  493.     glVertex3f(x + rozmiar, y - rozmiar, -rozmiar);
  494.     glEnd();
  495.  
  496.     glBegin(GL_LINE_LOOP);
  497.     glVertex3f(x + rozmiar, y - rozmiar, rozmiar);
  498.     glVertex3f(x - rozmiar, y - rozmiar, rozmiar);
  499.     glVertex3f(x - rozmiar, y - rozmiar, -rozmiar);
  500.     glVertex3f(x + rozmiar, y - rozmiar, -rozmiar);
  501.     glEnd();
  502.  
  503.  
  504.     glBegin(GL_LINE_LOOP);
  505.     glVertex3f(x + rozmiar, y + rozmiar, rozmiar);
  506.     glVertex3f(x - rozmiar, y + rozmiar, rozmiar);
  507.     glVertex3f(x - rozmiar, y + rozmiar, -rozmiar);
  508.     glVertex3f(x + rozmiar, y + rozmiar, -rozmiar);
  509.     glEnd();
  510.     //
  511.     glColor3f(0.0, 1.0, 0.0);
  512.     glBegin(GL_LINE_LOOP);
  513.     glVertex3f(x - rozmiar, y + rozmiar, rozmiar);
  514.     glVertex3f(x - rozmiar, y - rozmiar, rozmiar);
  515.     glVertex3f(x - rozmiar, y - rozmiar, -rozmiar);
  516.     glVertex3f(x - rozmiar, y + rozmiar, -rozmiar);
  517.     glEnd();
  518.  
  519.     glBegin(GL_LINE_LOOP);
  520.     glVertex3f(x + rozmiar, y + rozmiar, rozmiar);
  521.     glVertex3f(x + rozmiar, y - rozmiar, rozmiar);
  522.     glVertex3f(x + rozmiar, y - rozmiar, -rozmiar);
  523.     glVertex3f(x + rozmiar, y + rozmiar, -rozmiar);
  524.     glEnd();
  525.  
  526.  
  527. }
  528.  
  529. void Rysuj()
  530. {
  531.     int kolizja = -1;
  532.     glMatrixMode(GL_MODELVIEW);
  533.     glLoadIdentity();
  534.     // czyszczenie bufora koloru
  535.     glClearColor(1.0, 1.0, 1.0, 1.0);
  536.     glClear(GL_COLOR_BUFFER_BIT);
  537.  
  538.     glScalef(0.01, 0.01, 0.01);
  539.     //cout << "Licznik wynosi: " << licznik << endl;
  540.  
  541.     kostka *figura = new kostka[4];
  542.     //aktualnaSpadajacaFigura = 5;
  543.     rysujOdpowiedniegoKlocka(ruch, figura);
  544.     //figuraO(figura, forma);
  545.  
  546.     //FUNKCJA DO DODANIA!
  547.     wyznacz_granx(figura);
  548.  
  549.     if (ruch == true){
  550.         licznik = licznik + delta;
  551.         glPushMatrix();
  552.  
  553.         //DODAC OBSLUGE KOLIZJI
  554.  
  555.         kolizja = kolizja_boczna(figura, kloce, ster, licznik);
  556.         if (kolizja == 0) glTranslatef(ster, -licznik, 0);
  557.         else if (kolizja == 1) {
  558.             ster = ster + (rozmiar * 2);
  559.             glTranslatef(ster, -licznik, 0);
  560.         }
  561.         else if (kolizja == 2) {
  562.             ster = ster - (rozmiar * 2);
  563.             glTranslatef(ster, -licznik, 0);
  564.         }
  565.  
  566.         //glRotatef(kat, 0, 0, 1);
  567.         //glScalef(0.1, 0.1, 0.1);
  568.  
  569.         szescian(figura[0].wspx, figura[0].wspy);
  570.         szescian(figura[1].wspx, figura[1].wspy);
  571.         szescian(figura[2].wspx, figura[2].wspy);
  572.         szescian(figura[3].wspx, figura[3].wspy);
  573.  
  574.         // cout << "Wspolrzedne figury wynosza: x:" << figura[0].wspx+ster << " y:" << figura[0].wspy-licznik << endl;
  575.  
  576.         glPopMatrix();
  577.         figura[0].transx = ster;
  578.         figura[0].transy = licznik;
  579.         figura[1].transx = ster;
  580.         figura[1].transy = licznik;
  581.         figura[2].transx = ster;
  582.         figura[2].transy = licznik;
  583.         figura[3].transx = ster;
  584.         figura[3].transy = licznik;
  585.         if (czy_stop(figura, kloce, wskaznik) == true){
  586.  
  587.             //ZWIEKSZENIE GLOBALNEJ TABLICY KLOCY
  588.             kostka* klocetemp = new kostka[wskaznik + 4];
  589.  
  590.             for (int i = 0; i < wskaznik; i++){
  591.                 klocetemp[i].wspx = kloce[i].wspx;
  592.                 klocetemp[i].wspy = kloce[i].wspy;
  593.                 klocetemp[i].transx = kloce[i].transx;
  594.                 klocetemp[i].transy = kloce[i].transy;
  595.                 klocetemp[i].granicalewa = kloce[i].granicalewa;
  596.                 klocetemp[i].granicaprawa = kloce[i].granicaprawa;
  597.                 //PODODAWAC GRANICE!!!!
  598.             }
  599.  
  600.             klocetemp[wskaznik].wspx = figura[0].wspx;
  601.             klocetemp[wskaznik].wspy = figura[0].wspy;
  602.             klocetemp[wskaznik].transx = ster;
  603.             klocetemp[wskaznik].transy = licznik;
  604.             klocetemp[wskaznik].granicalewa = figura[0].granicalewa;
  605.             klocetemp[wskaznik].granicaprawa = figura[0].granicaprawa;
  606.  
  607.             klocetemp[wskaznik + 1].wspx = figura[1].wspx;
  608.             klocetemp[wskaznik + 1].wspy = figura[1].wspy;
  609.             klocetemp[wskaznik + 1].transx = ster;
  610.             klocetemp[wskaznik + 1].transy = licznik;
  611.             klocetemp[wskaznik + 1].granicalewa = figura[1].granicalewa;
  612.             klocetemp[wskaznik + 1].granicaprawa = figura[1].granicaprawa;
  613.  
  614.             klocetemp[wskaznik + 2].wspx = figura[2].wspx;
  615.             klocetemp[wskaznik + 2].wspy = figura[2].wspy;
  616.             klocetemp[wskaznik + 2].transx = ster;
  617.             klocetemp[wskaznik + 2].transy = licznik;
  618.             klocetemp[wskaznik + 2].granicalewa = figura[2].granicalewa;
  619.             klocetemp[wskaznik + 2].granicaprawa = figura[2].granicaprawa;
  620.  
  621.             klocetemp[wskaznik + 3].wspx = figura[3].wspx;
  622.             klocetemp[wskaznik + 3].wspy = figura[3].wspy;
  623.             klocetemp[wskaznik + 3].transx = ster;
  624.             klocetemp[wskaznik + 3].transy = licznik;
  625.             klocetemp[wskaznik + 3].granicalewa = figura[3].granicalewa;
  626.             klocetemp[wskaznik + 3].granicaprawa = figura[3].granicaprawa;
  627.  
  628.             delete[] kloce;
  629.             wskaznik = wskaznik + 4;
  630.             kloce = new kostka[wskaznik];
  631.  
  632.             for (int i = 0; i < wskaznik; i++){
  633.                 kloce[i].wspx = klocetemp[i].wspx;
  634.                 kloce[i].wspy = klocetemp[i].wspy;
  635.                 kloce[i].transx = klocetemp[i].transx;
  636.                 kloce[i].transy = klocetemp[i].transy;
  637.                 kloce[i].granicalewa = klocetemp[i].granicalewa;
  638.                 kloce[i].granicaprawa = klocetemp[i].granicaprawa;
  639.                 cout << "Przekazano dane: " << kloce[i].wspx << ":" << kloce[i].wspy << " ; " << kloce[i].transx << ":" << kloce[i].transy << endl;
  640.             }
  641.             delete[] klocetemp;
  642.  
  643.             flag = 1;
  644.             licznik = 0;
  645.             ster = 0;
  646.             ruch = false;
  647.             if (ruch == false){
  648.                 aktualnaSpadajacaFigura = losujKtoraFigureWygenerowac(0, 7, 0);
  649.                 cout << "RUCH:::" << ruch << "TEMP: 0" << aktualnaSpadajacaFigura << endl;
  650.             }
  651.         }
  652.  
  653.     }
  654.  
  655.  
  656.  
  657.  
  658.  
  659.  
  660.     if (flag == 1){
  661.         //figura[0].transx = ster;
  662.         //figura[0].transy = licznik;
  663.         //figura[1].transx = ster;
  664.         //figura[1].transy = licznik;
  665.         //figura[2].transx = ster;
  666.         //figura[2].transy = licznik;
  667.         //figura[3].transx = ster;
  668.         //figura[3].transy = licznik;
  669.  
  670.         for (int i = 0; i < wskaznik; i++){
  671.             glPushMatrix();
  672.             glTranslatef(kloce[i].transx, -kloce[i].transy, 0);
  673.             szescian(kloce[i].wspx, kloce[i].wspy);
  674.             glPopMatrix();
  675.         }
  676.  
  677.         ruch = true;
  678.  
  679.  
  680.  
  681.     }
  682.  
  683.     //glCallList(listid + 3);
  684.     Sleep(100);
  685.     // glutPostRedisplay();
  686.     glFlush();
  687.     glutSwapBuffers();
  688.  
  689. }
  690.  
  691. void GenerateDisplayLists(){
  692.  
  693.     listid = glGenLists(3);
  694.  
  695.     glNewList(listid + 0, GL_COMPILE);
  696.  
  697.     szescian(0, 4);
  698.     szescian(0, 2);
  699.     szescian(0, 0);
  700.     szescian(0, -2);
  701.     glEndList();
  702.  
  703.     glNewList(listid + 1, GL_COMPILE);
  704.     szescian(-2, 4);
  705.     szescian(-2, 2);
  706.     szescian(0, 2);
  707.     szescian(0, 0);
  708.     glEndList();
  709.  
  710.     glNewList(listid + 2, GL_COMPILE);
  711.     szescian(-2, 2);
  712.     szescian(0, 2);
  713.     szescian(0, 0);
  714.     szescian(0, -2);
  715.     glEndList();
  716.  
  717.     glNewList(listid + 3, GL_COMPILE);
  718.     szescian(0, 2);
  719.     szescian(-2, 0);
  720.     szescian(0, 0);
  721.     szescian(0, -2);
  722.     glEndList();
  723.  
  724.  
  725.  
  726.  
  727.  
  728. }
  729. void Reshape(int width, int height)
  730. {
  731.     // obszar renderingu - ca³e okno
  732.     glViewport(0, 0, width, height);
  733.  
  734.     // wybór macierzy rzutowania
  735.     glMatrixMode(GL_PROJECTION);
  736.  
  737.     // macierz rzutowania = macierz jednostkowa
  738.     glLoadIdentity();
  739.  
  740.     Rysuj();
  741. }
  742. void SpecialKeys(int key, int x, int y)
  743. {
  744.     switch (key)
  745.     {
  746.         // kursor w lewo
  747.     case GLUT_KEY_RIGHT:
  748.         ster = ster + 20;
  749.         break;
  750.     case GLUT_KEY_LEFT:
  751.         ster = ster - 20;
  752.         break;
  753.     case GLUT_KEY_UP:
  754.         upKeyControl();
  755.         break;
  756.     case GLUT_KEY_DOWN:
  757.         break;
  758.     }
  759.  
  760.     // odrysowanie okna
  761.     Reshape(glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT));
  762. }
  763.  
  764. int main(int argc, char *argv[])
  765. {
  766.     // inicjalizacja biblioteki GLUT
  767.     glutInit(&argc, argv);
  768.  
  769.  
  770.     // inicjalizacja bufora ramki
  771.     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  772.  
  773.  
  774.     // rozmiary g³ównego okna programu
  775.     glutInitWindowSize(800, 800);
  776.  
  777.  
  778.     // utworzenie g³ównego okna programu
  779.     glutCreateWindow("Tetris");
  780.     // Display();
  781.     //Rysuj();
  782.     glutDisplayFunc(Rysuj);
  783.     glutReshapeFunc(Reshape);
  784.     //glutKeyboardFunc(Keyboard);
  785.     GenerateDisplayLists();
  786.     glutSpecialFunc(SpecialKeys);
  787.     glutIdleFunc(Rysuj);
  788.     glutMainLoop();
  789.     return 0;
  790. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!