pastebin - śmietnik na Twój kod

pastebin to narzędzie pozwalające na dzielenie się oraz modyfikowanie fragmentów kodów podczas rozmowy na IRCu, poprzez komunikator internetowy lub na forum.

Ta strona jest przeznaczona dla XHTML oraz CSS2 W3C. Jeżeli widzisz tą wiadomość, musisz pobrać aktualizację dla swojej przeglądarki. Przejdź do WaSP aby to zrobić.

C++ Pastebin - Wklejanie i udostępnianie fragmentów kodu Zobacz pomoc

Posted by Anonim on Sat 16th Jan 01:21 (zmodyfikowany post przez zobacz różnice)
Zobacz odpowiedź od Heh | ściągnij jako plik | nowy wpis

  1. #include <iostream>
  2. #include <ctime>   // time()
  3. #include <cstdlib> // srand()
  4.  
  5. using namespace std;
  6.  
  7. class kulka  // elementarne pole - "kulka"
  8. {
  9. private:
  10.   kulka *lewo;
  11.   kulka *prawo;
  12.   kulka *dol;
  13.   kulka *gora;
  14.   int lewo_wartosc, prawo_wartosc, dol_wartosc, gora_wartosc;  // wagi
  15.   bool czy_odwiedzona,czy_przeszkoda;
  16.   void wyswietl(int StartMeta);
  17. public:
  18.   kulka();
  19.   friend void PokazPlansze(kulka &plansza, int rozmiar, int wynik, int iks, int igrek);  // zaprzyjaznione funkcje, 
  20.   friend int WczytajRozmiarIPokazFabule();                                               // nie dajemy dostepu
  21.   friend void TworzPlansze(int rozmiar_planszy, kulka &start);                           // do skladnikow prywatnych
  22.   friend void Graj(int rozmiar_planszy, kulka &start);                                   // nikomu innemu (enkapsulacja)
  23. };
  24.  
  25. kulka::kulka() // konstruktor
  26. {
  27.   lewo=NULL;
  28.   prawo=NULL;
  29.   dol=NULL;
  30.   gora=NULL;
  31.   czy_odwiedzona=false;
  32.   lewo_wartosc=rand()%6+5, prawo_wartosc=rand()%5+1, dol_wartosc=rand()%5+1, gora_wartosc=rand()%6+5; // losowe wartości
  33.   (rand()%10==3) ? czy_przeszkoda=true : czy_przeszkoda=false;
  34. }
  35.  
  36. void kulka::wyswietl(int StartMeta) // wyswietlanie jednej pojedynczej kulki
  37. {
  38.         if(StartMeta==0)
  39.         {
  40.                 if(!czy_odwiedzona && !czy_przeszkoda)cout << " . ";
  41.                 else if(!czy_odwiedzona && czy_przeszkoda) cout << " # ";
  42.                 else cout << "   ";
  43.         }
  44.         else
  45.         {
  46.                 (StartMeta==1) ? cout << " S " : cout << " M ";
  47.         }
  48. }
  49.  
  50. void PokazPlansze(kulka &plansza, int rozmiar, int wynik, int iks, int igrek)
  51. {
  52.         system("cls");
  53.         kulka *x=&plansza, *x1=x->prawo;
  54.         x=x->prawo;
  55.         cout << "\n";
  56.         for(int i=0; i<rozmiar; i++) // wiersze
  57.         {
  58.                 for(int j=0; j<rozmiar; j++) // kolumny
  59.                 {
  60.                         if(i==0 && j==0 && wynik==0) x->wyswietl(1);  // wyswietlenie startu - reagujemy na wspolrzedne w lewym gorym rogu planszy
  61.                         else if(i==rozmiar-1 && j==rozmiar-1)
  62.                         {
  63.                                 if(iks==rozmiar-1 && igrek==rozmiar-1) cout << " W "; // wyswietlenie mety - reagujemy na wspolrzedne w prawym dolnym koncu planszy
  64.                                 else x->wyswietl(2);
  65.                                 x->dol_wartosc=999; // tak bedziemy potem sprawdzac czy jest meta
  66.                                 x->prawo_wartosc=999; // j.w.
  67.                         }
  68.                                 else if(i==igrek && j==iks) cout << " W ";
  69.                                         else x->wyswietl(0);
  70.                         x=x->prawo;
  71.                 }
  72.                 (i==rozmiar-1) ? cout << "" : cout << "\n";
  73.                 x1=x1->dol;
  74.                 x=x1;
  75.         }
  76.         cout << "\n                                                             Ilosc pkt: " << wynik << "\n";
  77. }
  78.  
  79. int WczytajRozmiarIPokazFabule()
  80. {
  81.         system("cls");
  82.         cout << "Sredniowiecze. Wyspa Fiord. \n"
  83.                 << "Kierujesz oblezeniem zamku nieprzyjaciela.\n"
  84.                 << "Musisz przemiescic wieze obleznicza z punktu S do punktu M, \n"
  85.                 << "Zostawiasz za soba pulapki wiec nie mozesz odwiedzic 2 razy tego samego\n"
  86.                 << "pola, bo wpadniesz we wlasne sidla!\n"
  87.                 << "Trzymaj sie wyspy, dookola niej grasuja krwiozercze rekiny!\n"
  88.                 << "Wieza jest popsuta - w prawo i w dol moze byc ciezko nia sterowac.\n"
  89.                 << "Ruchy w lewo i w gore sa punktowanie dwukrotnie.\n"
  90.                 << "Uwazaj, zeby nie wpasc w zasadzke wroga (#) \n\n";
  91.        
  92.   int rozmiar_planszy;
  93.   do{
  94.         cout << "Podaj rozmiar wyspy: ";
  95.         cin >> rozmiar_planszy;
  96.         if(rozmiar_planszy < 2) cout << "Zly rozmiar planszy!\n";
  97.   } while(rozmiar_planszy < 2);
  98.   return rozmiar_planszy;
  99. }
  100.  
  101. void TworzPlansze(int rozmiar_planszy, kulka &start)  // funkcja tworzaca plansze o dowonym rozmiarze; polaczenia pinowe i poziome
  102. {
  103.   kulka *biezaca, *poczatek, *x, *y,*x1,*y1;
  104.   biezaca=&start;
  105.   poczatek=&start;
  106.   x=&start;
  107.   int ograniczam=0; // najpierw w rzedzie sa wszystkie kulki
  108.   for(int j=0; j<rozmiar_planszy; j++) // n rzedow
  109.   {
  110.           for(int i=0; i<rozmiar_planszy-ograniczam; i++) //tworzenie jednego rzedu
  111.           {
  112.                   biezaca->prawo=new kulka;
  113.                   biezaca->prawo->lewo=biezaca;
  114.                   if(i==0 && j==0) biezaca->prawo->lewo=NULL; // z kulki start (inicjalizatora) mozemy isc tylko w prawo, wrocic nie mozemy bo to nie jest wlasciwa plansza
  115.                   biezaca=biezaca->prawo;
  116.           }
  117.           if(j==0)
  118.           {
  119.                   poczatek->prawo->dol=new kulka; // pierwsze powiazanie pionowe
  120.                   poczatek->prawo->dol->gora=poczatek->prawo; // j.w, reverse
  121.                   x=poczatek->prawo;
  122.                   y=poczatek->prawo->dol;
  123.                   poczatek=poczatek->prawo->dol;
  124.                   biezaca=poczatek;
  125.                   ograniczam=1; // nastepne rzedy beda mialy o 1 kulke mniej bo juz jedna zrobilismy (ta dolna)
  126.           }
  127.           else if(j<=rozmiar_planszy-2)
  128.           {
  129.                   poczatek->dol=new kulka;
  130.                   poczatek->dol->gora=poczatek;
  131.                   poczatek=poczatek->dol;
  132.                   biezaca=poczatek;
  133.                   ograniczam=1; // j.w.
  134.           }
  135.   }
  136.   x1=x;  //
  137.   y1=y;  // poreczowki
  138.   for(int i=0; i<rozmiar_planszy-1; i++) // polaczenia pionowe
  139.   {
  140.                 for(int j=0; j<rozmiar_planszy-1; j++) // powiazania pionowe w jednym poziomie
  141.                 {
  142.                         x=x->prawo;
  143.                         y=y->prawo;
  144.                         x->dol=y;
  145.                         x->dol->gora=x;
  146.                 }
  147.                 x1=x1->dol; // ok, teraz musimy udac sie nizej powiazac inne kulki pionowo
  148.                 x=x1;
  149.                 y1=y1->dol;
  150.                 y=y1;
  151.   }
  152. }
  153.  
  154. void Graj(int rozmiar_planszy, kulka &start)
  155. {
  156.   kulka  *pozycja;
  157.   int wynik=0;
  158.   PokazPlansze(start, rozmiar_planszy, wynik, 999, 999);
  159.   pozycja=start.prawo;
  160.   start.prawo->czy_odwiedzona=true;
  161.   char wybor;
  162.  
  163.   bool NieMaMety=true;
  164.   int x2=0, y2=0;
  165.   while(NieMaMety)
  166.   {
  167.           cout << "w - w gore   s - w dol   a - w lewo   d - w prawo  p - wyjscie   ";
  168.           cin >> wybor;
  169.           switch (wybor)
  170.           {
  171.           case 'w':
  172.                   if((pozycja->gora) && (!pozycja->gora->czy_odwiedzona) && (!pozycja->gora->czy_przeszkoda))  // z dolu do mety nie da sie dojsc wiec tu nie sprawdzamy mety
  173.                   {
  174.                       y2-=1;
  175.                           pozycja->gora->czy_odwiedzona=true;
  176.                           wynik=wynik+pozycja->gora_wartosc;
  177.                           pozycja=pozycja->gora;
  178.                   }
  179.                   else
  180.                   {
  181.                           cout << "\nGame over! Twoj wynik: " << wynik << endl;
  182.                           cin.get();
  183.                           cin.get();
  184.                           exit(0);
  185.                   }
  186.                   break;
  187.           case 's':
  188.                   if((pozycja->dol) && (!pozycja->dol->czy_odwiedzona) && (!pozycja->dol->czy_przeszkoda))
  189.                   {
  190.                           y2+=1;
  191.                           wynik=wynik+pozycja->dol_wartosc;
  192.                           if(pozycja->dol->dol_wartosc==999)
  193.                           {
  194.                                   cout << "Meta!";  // wykrywanie mety jak idziemy na nia z gory
  195.                                   NieMaMety=false;
  196.                           }
  197.                           else pozycja->dol->czy_odwiedzona=true;
  198.                           pozycja=pozycja->dol;
  199.                   }
  200.                   else
  201.                   {
  202.                           cout << "\nGame over! Twoj wynik: " << wynik << endl;
  203.                           cin.get();
  204.                           cin.get();
  205.                           exit(0);
  206.                   }
  207.                   break;
  208.           case 'd':
  209.                   if((pozycja->prawo) && (!pozycja->prawo->czy_odwiedzona) && (!pozycja->prawo->czy_przeszkoda))
  210.                   {
  211.                           x2+=1;
  212.                           wynik=wynik+pozycja->prawo_wartosc;
  213.                           if(pozycja->prawo->prawo_wartosc==999)
  214.                           {
  215.                                   cout << "Meta!";  // wykrywanie mety jak idziemy na nia z lewej
  216.                                   NieMaMety=false;
  217.                           }
  218.                           else pozycja->prawo->czy_odwiedzona=true;
  219.                           pozycja=pozycja->prawo;
  220.                   }
  221.                 else
  222.                   {
  223.                           cout << "\nGame over! Twoj wynik: " << wynik << endl;
  224.                           cin.get();
  225.                           cin.get();
  226.                           exit(0);
  227.                   }
  228.                   break;
  229.           case 'a':
  230.                   if((pozycja->lewo) && (!pozycja->lewo->czy_odwiedzona) && (!pozycja->lewo->czy_przeszkoda)) // z prawej na mete nie da sie dojsc wiec tu nie sprawdzamy mety
  231.                   {
  232.                           x2-=1;
  233.                           wynik=wynik+pozycja->lewo_wartosc;
  234.                           pozycja->lewo->czy_odwiedzona=true;
  235.                           pozycja=pozycja->lewo;
  236.                   }
  237.                 else
  238.                   {
  239.                           cout << "\nGame over! Twoj wynik: " << wynik << endl;
  240.                           cin.get();
  241.                           cin.get();
  242.                           exit(0);
  243.                   }
  244.                   break;
  245.           case 'p':
  246.                   cin.get();
  247.                   cin.get();
  248.                   exit(0);
  249.                   break;
  250.           default:
  251.                   cout << "Gdzie? Nie znam takiego kierunku!";
  252.           }
  253.           PokazPlansze(start, rozmiar_planszy, wynik, x2, y2);
  254.   }
  255.   cout << "Brawo! Jestes dobrym dowodca!"
  256.           << "\nMianuje Cie na dowodce kierowania maszynami oblezniczymi! Twoj wynik: " << wynik << endl;
  257. }
  258.  
  259. int main()
  260. {
  261.         srand(time(NULL));  // losowosc przejsc miedzy kulkami
  262.         kulka start;  // kulka inicjalizujaca "starter"
  263.         while(1)
  264.         {
  265.                 int rozmiar_planszy = WczytajRozmiarIPokazFabule();  // user podaje rozmiar planszy
  266.                 TworzPlansze(rozmiar_planszy, start);  // stworzenie struktury calej planszy, polaczen etc
  267.                 Graj(rozmiar_planszy, start);  // wlasciwa gra
  268.                 cin.get(); // odpowiednik system("pause");
  269.                 cin.get(); //
  270.         }
  271.         return 0;
  272. }

Wyślij poprawkę poniżej (kliknij tu aby wysłać nowy wpis)
Po wysłaniu poprawki będziesz w stanie łatwo zobaczyć różnice między starym a nowym wpisem.

Podświetlanie składni:

Aby podświetlić konkretną linię, wpisz na jej początku @@


Zapamiętaj mniePrivate
Nie wypełniaj tego pola ! =>