[C++] busy wait

[[C++] busy wait]

Tamten problem rozwiązałem dodając taki kod przed fclose:

//Rozwiazanie tymczasowe
    tablica_wynikow[licznik_struktur].punkty=atoi(napispunktow);
    licznik_znakow=0;
    while(tempimie[licznik_znakow]!=0 ){
        tablica_wynikow[licznik_struktur].nazwisko[licznik_znakow]=tempimie[licznik_znakow];
        licznik_znakow=licznik_znakow+1;
    }
    //Koniec rozwiazania tymczasowego

Jak widać jest to tzw. "quick and dirty solution" jak mawiają amerykanie.

 

Teraz mam problem z sortowaniem tablicy struktur wyników:

void sortujwyniki(tabelawynikowa tablica_wynikow[11]){
    tabelawynikowa kopia[11];
    int wykorzystanie[11];
    int licznik=0;
    //Skopiowanie struktury wynikow
    while(licznik<11){
        kopia[licznik]=tablica_wynikow[licznik];
        wykorzystanie[licznik]=0;
        licznik=licznik+1;
    }
    licznik=0;

    int licznik2=0;
    int najwieksza=-1;
    int numer=-1;

    while(licznik2<11){
        licznik=0;
        while(licznik<11){
            if((kopia[licznik].punkty>najwieksza)&&(wykorzystanie[licznik]==0)){
                najwieksza=kopia[licznik].punkty;
                numer=licznik;
            }
            licznik=licznik+1;
        }
        tablica_wynikow[licznik2]=kopia[numer];
        wykorzystanie[numer]=1;

        licznik2=licznik2+1;
    }
}

Wydaje same bajwyższe wyniki i nazwy gracza, który je uzyskał. Kopiowanie na pewno działa dobrze - sprawdziłem.

[[C++] busy wait]

Zrobiłem funkcje

1:Wczytanie pliku wyników do programu.

void wczytajwyniki(tabelawynikowa tablica_wynikow[11],int tryb,int punkty){
    //Odczyt pliku z tablica wynikow
    int znak;
    int tryb_odczytu_znakow = 0; //0-liczby 1-napis
    int licznik_znakow;
    char napispunktow[10];
    char tempimie[63];
    int licznik_zerowania=0;
    int licznik_struktur=0;

    licznik_zerowania=0;
        while(licznik_zerowania<10){
            napispunktow[licznik_zerowania]=0;
            licznik_zerowania=licznik_zerowania+1;
        }

    licznik_zerowania=0;
    while(licznik_struktur<11){
        while(licznik_zerowania<63){
            tablica_wynikow[licznik_struktur].nazwisko[licznik_zerowania]=0;
            licznik_zerowania=licznik_zerowania+1;
        }
        licznik_struktur=licznik_struktur+1;
        licznik_zerowania=licznik_zerowania+1;
    }
    licznik_zerowania=0;
    licznik_struktur=0;


    FILE *plik = fopen( "wyniki.txt", "r" );
    znak = getc( plik );
    licznik_znakow=0;
    while(znak != EOF){
        if(znak=='|'){
            tryb_odczytu_znakow=1;
            licznik_zerowania=0;
            while(licznik_zerowania<63){
                tempimie[licznik_zerowania]=0;
                licznik_zerowania=licznik_zerowania+1;
            }
            licznik_znakow=0;
        }else
        if(znak=='/'){
            tryb_odczytu_znakow=0;
            licznik_znakow=0;
        }else
        if(znak=='\n'){
            licznik_znakow=0;
            while(licznik_znakow<63){
                tablica_wynikow[licznik_struktur].nazwisko[licznik_znakow]=tempimie[licznik_znakow];
                licznik_znakow=licznik_znakow+1;
            }
            tablica_wynikow[licznik_struktur].punkty=atoi(napispunktow);
            licznik_struktur=licznik_struktur+1;
            licznik_zerowania=0;
            while(licznik_zerowania<10){
                napispunktow[licznik_zerowania]=0;
                licznik_zerowania=licznik_zerowania+1;
            }
            licznik_znakow=0;

        }else{

            if(tryb_odczytu_znakow==0){
                napispunktow[licznik_znakow]=znak;
                licznik_znakow=licznik_znakow+1;
            }
            if(tryb_odczytu_znakow==1){
                tempimie[licznik_znakow]=znak;
                licznik_znakow=licznik_znakow+1;
            }
        }
        znak = getc( plik );
    }

    fclose( plik );

    if(tryb==1){
        cout <<endl << "Podaj swoje imie" << endl;
        cin.get(tablica_wynikow[10].nazwisko,63);
        tablica_wynikow[10].punkty=punkty;
    }else{
    ;
    }

}

2: Wyświetlenie tablicy struktur:

void wyswietlwyniki(tabelawynikowa tablica_wynikow[11],int tryb){

    cout<<endl<<"Tablica wynikow"<<endl;
    int licznik_struktur=0;
    int limit;
    if(tryb==0){
        limit=10;
    }
    if(tryb==1){
        limit=11;
    }
    cout<<"gracz-------wynik"<<endl;
    while(licznik_struktur<limit){
        cout<<tablica_wynikow[licznik_struktur].nazwisko<<"   " <<tablica_wynikow[licznik_struktur].punkty<< "punktow"<<endl;
        licznik_struktur=licznik_struktur+1;

    }
    cout<<endl;
    cout<<endl;


}

No i mam mały problem - nie wczytuje 10 pozycji z pliku. Jak to naprawić?

Pozostało mi jeszcze do napisania funkcja sortowania oraz zapisu do pliku.

[[C++] busy wait]

Udało mi się naprawić:

FILE *plik = fopen( "wyniki.txt", "r" );
    znak = getc( plik );
    licznik_znakow=0;
    while(znak != EOF){
        if(znak=='|'){
            tryb_odczytu_znakow=1;
            licznik_zerowania=0;
            while(licznik_zerowania<63){
                tempimie[licznik_zerowania]=0;
                licznik_zerowania=licznik_zerowania+1;
            }
            licznik_znakow=0;
        }else
        if(znak=='/'){
            tryb_odczytu_znakow=0;
            licznik_znakow=0;
        }else
        if(znak=='\n'){
            licznik_znakow=0;
            while(licznik_znakow<63){
                tablica_wynikow[licznik_struktur].nazwisko[licznik_znakow]=tempimie[licznik_znakow];
                licznik_znakow=licznik_znakow+1;
            }
            tablica_wynikow[licznik_struktur].punkty=atoi(napispunktow);
            licznik_struktur=licznik_struktur+1;
            licznik_zerowania=0;
            while(licznik_zerowania<10){
                napispunktow[licznik_zerowania]=0;
                licznik_zerowania=licznik_zerowania+1;
            }
            licznik_znakow=0;

        }else{

            if(tryb_odczytu_znakow==0){
                napispunktow[licznik_znakow]=znak;
                licznik_znakow=licznik_znakow+1;
            }
            if(tryb_odczytu_znakow==1){
                tempimie[licznik_znakow]=znak;
                licznik_znakow=licznik_znakow+1;
            }
        }
        znak = getc( plik );
    }

    fclose( plik );

Co sądzisz o takim rozwiązaniu?

[[C++] busy wait]

Tak, wyświetla same zera.

 

[[C++] busy wait]

Poprawiłem.

Nie wiem jak mogłem popełnić tak prosty błąd.

Mam jednak dalej problem z przepisaniem liczby z napisu na zmienną typu int.

Kod:

    FILE *plik = fopen( "wyniki.txt", "r" );
    znak = getc( plik );
    while(znak != EOF){
        if(znak=='|'){
            tryb_odczytu_znakow=1;
            licznik_zerowania=0;
            while(licznik_zerowania<63){
                tempimie[licznik_zerowania]=0;
                licznik_zerowania=licznik_zerowania+1;
            }
            licznik_znakow=0;
        }
        if(znak=='/'){
            tryb_odczytu_znakow=0;
            licznik_znakow=0;
        }
        if(znak=='\n'){
            licznik_znakow=0;
            while(licznik_znakow<63){
                tablica_wynikow[licznik_struktur].nazwisko[licznik_znakow]=tempimie[licznik_znakow];
                licznik_znakow=licznik_znakow+1;
            }
            tablica_wynikow[licznik_struktur].punkty=atoi(napispunktow);
            licznik_struktur=licznik_struktur+1;
            licznik_zerowania=0;
            while(licznik_zerowania<10){
                napispunktow[licznik_zerowania]=0;
                licznik_zerowania=licznik_zerowania+1;
            }

        }else{

            if(tryb_odczytu_znakow==0){
                napispunktow[licznik_znakow]=znak;
                licznik_znakow=licznik_znakow+1;
            }
            if(tryb_odczytu_znakow==1){
                tempimie[licznik_znakow]=znak;
                licznik_znakow=licznik_znakow+1;
            }
        }
        znak = getc( plik );
    }

    fclose( plik );

 

[[C++] busy wait]

Dostawiłem getc. Dalej nie działa.

V

FILE *plik = fopen( "wyniki.txt", "r" );
    znak = getc( plik );
    while(znak != EOF){
        if(znak=='|'){
            tryb_odczytu_znakow=1;
            licznik_zerowania=0;
            while(licznik_zerowania<63){
                tempimie[licznik_zerowania]=0;
                licznik_zerowania=licznik_zerowania+1;
            }
            licznik_znakow=0;
        }
        if(znak=='/'){
            tryb_odczytu_znakow=0;
            licznik_znakow=0;
        }
        if(znak=='\n'){
            licznik_znakow=0;
            while(licznik_znakow<63){
                tablica_wynikow[licznik_struktur].nazwisko[licznik_znakow]=tempimie[licznik_znakow];
                licznik_znakow=licznik_znakow+1;
            }
            tablica_wynikow[licznik_struktur].punkty=atoi(napispunktow);
            licznik_struktur=licznik_struktur+1;
            licznik_zerowania=0;
            while(licznik_zerowania<10){
                napispunktow[licznik_zerowania]=0;
                licznik_zerowania=licznik_zerowania+1;
            }

        }else{

            if(tryb_odczytu_znakow==0){
                znak=napispunktow[licznik_znakow];
                licznik_znakow=licznik_znakow+1;
            }
            if(tryb_odczytu_znakow==1){
                znak=tempimie[licznik_znakow];
                licznik_znakow=licznik_znakow+1;
            }
        }
        znak = getc( plik );
    }

    fclose( plik );

Wstawiłem tylko tą cześć kodu, gdzie dostawiłem getc.

 

PS. W przypadku braku mozliwości wygenerowania pokarmu, to będzie zakończenie gry. Co do plansz, to zamierzam zrobić odczyt plansz z pliku, oraz możliwość przejścia węża na drugą stronę ekranu, gdy nie ma tych ścian dookoła planszy (ruch jak po powierzhni torusa - bryły geometrycznej przypominającej idealnie gładki precel).

Edit:

Przerobiłem kod programu tak, że teraz można chodzić wężem na ukos. Gdy wyświetlanie i zapisywanie wyników będzie gotowe, to Ci pokaże.

[[C++] busy wait]

Co do odczytu to wykombinowałem coś takiego:

 

    //Odczyt pliku z tablica wynikow
    int znak;
    int tryb_odczytu_znakow = 0; //0-liczby 1-napis
    int licznik_znakow;
    char napispunktow[10];
    char tempimie[63];
    int licznik_zerowania=0;
    int licznik_struktur=0;

    tabelawynikowa tablica_wynikow[11];

    licznik_zerowania=0;
        while(licznik_zerowania<10){
            napispunktow[licznik_zerowania]=0;
            licznik_zerowania=licznik_zerowania+1;
        }

    licznik_zerowania=0;
    while(licznik_struktur<11){
        while(licznik_zerowania<63){
            tablica_wynikow[licznik_struktur].nazwisko[licznik_zerowania]=0;
            licznik_zerowania=licznik_zerowania+1;
        }
        licznik_struktur=licznik_struktur+1;
        licznik_zerowania=licznik_zerowania+1;
    }
    licznik_zerowania=0;
    licznik_struktur=0;


    FILE *plik = fopen( "wyniki.txt", "r" );
    while(znak != EOF){
        if(znak=='|'){
            tryb_odczytu_znakow=1;
            licznik_zerowania=0;
            while(licznik_zerowania<63){
                tempimie[licznik_zerowania]=0;
                licznik_zerowania=licznik_zerowania+1;
            }
            licznik_znakow=0;
        }
        if(znak=='/'){
            tryb_odczytu_znakow=0;
            licznik_znakow=0;
        }
        if(znak=='\n'){
            licznik_znakow=0;
            while(licznik_znakow<63){
                tablica_wynikow[licznik_struktur].nazwisko[licznik_znakow]=tempimie[licznik_znakow];
                licznik_znakow=licznik_znakow+1;
            }
            tablica_wynikow[licznik_struktur].punkty=atoi(napispunktow);
            licznik_struktur=licznik_struktur+1;
            licznik_zerowania=0;
            while(licznik_zerowania<10){
                napispunktow[licznik_zerowania]=0;
                licznik_zerowania=licznik_zerowania+1;
            }

        }else{

            if(tryb_odczytu_znakow==0){
                znak=napispunktow[licznik_znakow];
                licznik_znakow=licznik_znakow+1;
            }
            if(tryb_odczytu_znakow==1){
                znak=tempimie[licznik_znakow];
                licznik_znakow=licznik_znakow+1;
            }
        }
    }

    fclose( plik );

    cout<<endl<<"Tablica wynikow"<<endl;

    licznik_struktur=0;
    while(licznik_struktur<10){
        cout<<"struktura NO"<<licznik_struktur<<endl;
        cout<<tablica_wynikow[licznik_struktur].nazwisko<<"   " <<tablica_wynikow[licznik_struktur].punkty<< "punktow"<<endl;
        licznik_struktur=licznik_struktur+1;
    }

Korzysta ze struktury

struct tabelawynikowa
{
    char nazwisko[63];
    int punkty;
};

Dla przypomienia plik do odczytu narazie wygląda tak:

12|gracz1/
24|gracz2/
56|gracz3/
90|gracz4
122|gracz5/
91|gracz6/
13|gracz7/
99|gracz8/
223|gracz9/
100|gracz10/

Niestety, gdy normalnie uruchamiam program to nie wyświetla nic ( w momencie, w którym powinien wyświtlić tablicę wyników wpada w pętlę nieskończoną), a jak uruchomię prze debug/countinue (czerona ikona w edytorze Code::Blocks) to nie wyświetla nazw graczy i do każdego daje 0 punktów:(

Gdzie mam błąd?

Z sotrowanie tablicy po dodaniu wyniku gracza to sobie poradzę.

PS: A jak zrobić zapis liczby int do pliku tekstowego?

[[C++] busy wait]

 A funkcja z zamianą ciągu cyfr-znaków na liczbę int i na odwrót. (atoi czy jakoś tak)  - jak używać?

Sprawdź, czy wzrost =0 na początku zadziała.(Patrrz  mój poprzedni post)

 

[[C++] busy wait]

Zamień int wzrost; na int wzrost=0;, wtedy powinno działać

Nie wiem, jak wkradł mi się ten błąd.

Co do pliku, to myślałem nad tekstowym. Czy jest jakaś biblioteka z funkcjmi do odczytu/zapisu liczb i napisów do takich plików?

[[C++] busy wait]

Zmodyfikowałem generowanie pokarmu oraz dodałem opcję super pokarmu (z fajnym sposobem liczenia punktów)

Co do esc - jeszcze nie ma, będzi wyświetlać plansze pauzy z możliwością przerwania gry.

 

#include <iostream>
#include <ctime>
#include <stdlib.h>
#include <Windows.h>
#include <fstream>

using namespace std;

//Stale - wielkosc planszy
    const int wiersze = 20;
    const int kolumny = 90;

    const int limitwynikow = 10;
//Deklaracja struktury segmentu weza;
struct segment
{
    int poz_wiersz;
    int poz_kolumna;
};
//Deklaracja struktury pokarmu do zebrania;
struct pokarm
{
    int poz_wiersz;
    int poz_kolumna;
};

pokarm karmaweza;

int super=0;

//Enumerator - kierunki
enum kierunki{
    gora=0,
    lewo=1,
    dol=2,
    prawo=3,
    escape=9
};


void wyswietl(char plansza[wiersze][kolumny], kierunki wektor);
void pokazweza(segment snake [(wiersze-2)*(kolumny-2)],int dlugosc);//FUNKCJA TYMCZASOWA
int przesunweza(segment snake [(wiersze-2)*(kolumny-2)],int & dlugosc,char plansza[wiersze][kolumny],kierunki wektor, int & punkty, int & wzrost);
void aktualizacja(char plansza[wiersze][kolumny],segment snake [(wiersze-2)*(kolumny-2)], int dlugosc);
void generujpokarm(char plansza[wiersze][kolumny]);

int main()
{
    srand( time( NULL ) );
    //waz jako tablica - rownanie wylicza makszymlna dlugosc weza;
    // segment o numerze 0 - glowa, pozostale - segmenty ogona;
    segment snake [(wiersze-2)*(kolumny-2)];
    //dlugosc weza - na poczatku gry glowa i 3 segmenty ogona
    int dlugosc = 4;
    int punkty = 0;

    //ustawianie poczatkowej pozycji weza
    int ustawianie=0;
    while(ustawianie<dlugosc){
        snake[ustawianie].poz_wiersz=1;
        snake[ustawianie].poz_kolumna=dlugosc+1-ustawianie;
        ustawianie=ustawianie+1;
    }


    //plansza gry
    char plansza [wiersze][kolumny];

    int wyswiersze = 0;
    int wyskolumny = 0;

    //===============================================================
    //Wypelnienie planszy
    while(wyswiersze<wiersze){
        while(wyskolumny<kolumny){
            plansza [wyswiersze][wyskolumny]=' ';
            wyskolumny = wyskolumny+1;
        }
        wyswiersze=wyswiersze+1;
        wyskolumny=0;
    }

    wyswiersze = 0;
    wyskolumny = 0;

    //ramka pozioma
    while (wyskolumny<kolumny){
        plansza[0][wyskolumny]= 'X';
        plansza[wiersze-1][wyskolumny]= 'X';
        wyskolumny=wyskolumny+1;
    }

    wyswiersze = 0;
    wyskolumny = 0;

    //ramka pionowa
    while (wyswiersze<wiersze){
        plansza[wyswiersze][0]= 'X';
        plansza[wyswiersze][kolumny-1]='X';
        wyswiersze=wyswiersze+1;
    }


    //Wstawianie weza do tablicy
    ustawianie=0;
    while(ustawianie<dlugosc){
            if(ustawianie==0){
                plansza[snake[ustawianie].poz_wiersz][snake[ustawianie].poz_kolumna]= 'G';
            }else{
                plansza[snake[ustawianie].poz_wiersz][snake[ustawianie].poz_kolumna]= 'O';
            }
        ustawianie=ustawianie+1;
    }

    //===============================================================

    //wyswietlenie planszy;
    cout << "Punkty: " << punkty << "          " << "Dlugosc weza: " << dlugosc<<endl;
    kierunki wektor= prawo;
    generujpokarm(plansza);
    wyswietl(plansza, wektor);



    bool granie = 1;
    float secs=0.1;
    int reakcja;
    int wzrost;

    while (granie==1){

        clock_t delay = secs * CLOCKS_PER_SEC;
        clock_t start = clock();
        while(clock() - start < delay){
            //Sprawdzenie czy jest nacisniety klawisz
            if(((GetKeyState('W') & 0x8000) && (wektor!=gora)) && (wektor!=dol))
            {
                wektor = gora;
                break;
            }
            if(((GetKeyState('A') & 0x8000) && (wektor!=lewo)) && (wektor!=prawo))
            {
                wektor = lewo;
                break;
            }
            if(((GetKeyState('S') & 0x8000) && (wektor!=dol)) && (wektor!=gora))
            {

                wektor = dol;
                break;
            }
            if(((GetKeyState('D') & 0x8000) && (wektor!=prawo)) && (wektor!=lewo))
            {
                wektor = prawo;
                break;
            }


        }
        reakcja = przesunweza(snake,dlugosc,plansza,wektor,punkty,wzrost);

        if ((reakcja==0) || (reakcja==2)){
            if(reakcja==2){
                generujpokarm(plansza);
            }
            aktualizacja(plansza,snake,dlugosc);
            system("CLS");
            cout << "Punkty: " << punkty << "          " << "Dlugosc weza: " << dlugosc<<endl;
            wyswietl(plansza, wektor);
        }
        if (reakcja==1){
            granie=0;
        }

    }

    system("CLS");
    cout << "             GAME OVER"<<endl;
    cout<< "Waz uderzyl w sciane lub we wlasny ogon"<<endl;
    cout<< "Wynik " <<punkty<<" punktow" <<endl;

    int znak;
    //FILE *plik = fopen( "wyniki.txt", "r" );
    //znak = getc( plik );

    //fclose( plik );

    cout<< "Nacisnij klawisz ENTER"<<endl;
    cin.get();





    return 0;
}



void wyswietl(char plansza[wiersze][kolumny], kierunki wektor){
    //wyswietlenie planszy;
    int wyswiersze = 0;
    int wyskolumny = 0;
    long wymiartablicy;
    wymiartablicy = (wiersze*(kolumny+2));
    char ekran [wymiartablicy];
    int licznik=0;


    while(wyswiersze<wiersze){
        while(wyskolumny<kolumny){
            if(plansza [wyswiersze][wyskolumny]!='G')
            {
                ekran[licznik]=plansza [wyswiersze][wyskolumny];
            }
            else{
                    if(wektor== gora){
                        ekran[licznik]='A';
                    }
                    if(wektor== lewo){
                        ekran[licznik]='<';
                    }
                    if(wektor== prawo){
                        ekran[licznik]='>';
                    }
                    if(wektor== dol){
                        ekran[licznik]='V';
                    }

            }
            wyskolumny = wyskolumny+1;
            licznik=licznik+1;
        }
        ekran[licznik]='\n';
        licznik=licznik+1;
        wyswiersze=wyswiersze+1;
        wyskolumny=0;
    }
    cout << ekran;

}

void pokazweza(segment snake [(wiersze-2)*(kolumny-2)],int dlugosc){
    int licznik=0;
    while(licznik<dlugosc){
        cout << "==========================================="<<endl;
        if(licznik==0){
            cout <<"GLOWA"<<endl;
        }
        else{
            cout << "SEGMENT no. " << licznik<<endl;
        }
        cout << "-------------------------------------------"<<endl;
        cout << "wartosc zmiennej poz_wiersz = " << snake[licznik].poz_wiersz<<endl;
        cout << "wartosc zmiennej poz_kolumna = " << snake[licznik].poz_kolumna<<endl;

        licznik=licznik+1;
    }

}

int przesunweza(segment snake [(wiersze-2)*(kolumny-2)],int & dlugosc,char plansza[wiersze][kolumny],kierunki wektor, int & punkty, int & wzrost){
    int licznik;
    segment glowa;//Przechowuje wspozedne glowy weza
    glowa=snake[0];

    enum wyjscia{
    puste_pole=0,
    pokarm=1,
    sciana=2,//lub ogon
    super=3,
    };
    wyjscia wartosc;

    switch(wektor){
        case gora:
            glowa.poz_wiersz=glowa.poz_wiersz-1;
            break;
        case lewo:
            glowa.poz_kolumna=glowa.poz_kolumna-1;
            break;
        case dol:
            glowa.poz_wiersz=glowa.poz_wiersz+1;
            break;
        case prawo:
            glowa.poz_kolumna=glowa.poz_kolumna+1;
            break;
            }


    //Sprawdzanie na jakie pole jest przesuwana glowa weza
    if (plansza[glowa.poz_wiersz][glowa.poz_kolumna]=='X'){
        wartosc=sciana;
        }else
    if (plansza[glowa.poz_wiersz][glowa.poz_kolumna]=='O'){
        wartosc=sciana;
        }else
    if (plansza[glowa.poz_wiersz][glowa.poz_kolumna]=='p'){
        wartosc=pokarm;
        }else
    if (plansza[glowa.poz_wiersz][glowa.poz_kolumna]==' '){
        wartosc=puste_pole;
        }
    if (plansza[glowa.poz_wiersz][glowa.poz_kolumna]=='s'){
        wartosc=super;
        }

    //=====================================================

    if(wartosc==1){
        wzrost=wzrost+1;
        punkty=punkty+1;
    }
    if(wartosc==3){
        int temp = ((rand() % 4 )+5);
        wzrost = temp;
        punkty=punkty+1+(temp*temp);
    }

    if(wartosc!=2){
        segment tymczasowa [dlugosc+2];
        licznik=0;
        while(licznik<dlugosc){//Kopiuje weza do tablicy tymczasowej
            tymczasowa[licznik]=snake[licznik];

            licznik=licznik+1;
        }
        snake[0]=glowa;
        licznik=1;
        while(licznik<dlugosc){
            snake[licznik]=tymczasowa[licznik-1];
            licznik=licznik+1;
        }
        if(wzrost>=1){
            snake[dlugosc]=tymczasowa[dlugosc-1];
            dlugosc=dlugosc+1;
            wzrost=wzrost-1;
        }
    }

    if (wartosc==2){//Zwraca 2 gdy glowa weza uderza o sciane lub o ogon
        return 1;
    }
    if (wartosc==1){
        return 2;
    }
    if (wartosc==3){
        return 2;
    }
    return 0;

}

void aktualizacja(char plansza[wiersze][kolumny],segment snake [(wiersze-2)*(kolumny-2)], int dlugosc){
    int wyswiersze = 0;
    int wyskolumny = 0;

    //===============================================================
    //Wypelnienie planszy
    while(wyswiersze<wiersze){
        while(wyskolumny<kolumny){
            plansza [wyswiersze][wyskolumny]=' ';
            wyskolumny = wyskolumny+1;
        }
        wyswiersze=wyswiersze+1;
        wyskolumny=0;
    }

    wyswiersze = 0;
    wyskolumny = 0;

    //ramka pozioma
    while (wyskolumny<kolumny){
        plansza[0][wyskolumny]= 'X';
        plansza[wiersze-1][wyskolumny]= 'X';
        wyskolumny=wyskolumny+1;
    }

    wyswiersze = 0;
    wyskolumny = 0;

    //ramka pionowa
    while (wyswiersze<wiersze){
        plansza[wyswiersze][0]= 'X';
        plansza[wyswiersze][kolumny-1]='X';
        wyswiersze=wyswiersze+1;
    }

    //Wstawianie weza do tablicy
    int ustawianie=0;
    while(ustawianie<dlugosc){
            if(ustawianie==0){
                plansza[snake[ustawianie].poz_wiersz][snake[ustawianie].poz_kolumna]= 'G';
            }else{
                plansza[snake[ustawianie].poz_wiersz][snake[ustawianie].poz_kolumna]= 'O';
            }
        ustawianie=ustawianie+1;
    }

    if (super==0){
        plansza[karmaweza.poz_wiersz][karmaweza.poz_kolumna]= 'p';
    }else{
        plansza[karmaweza.poz_wiersz][karmaweza.poz_kolumna]= 's';
    }



}

void generujpokarm(char plansza[wiersze][kolumny]){


    srand( time( NULL ) );
    long wybrane_pole;

    pokarm pola_pokarmu [(wiersze*kolumny)];

    int licznik_wierszy=0;
    int licznik_kolumn;
    long licznik_pol=0;

    while(licznik_wierszy<wiersze){
            licznik_kolumn=0;
            while(licznik_kolumn<kolumny){
                if(plansza[licznik_wierszy][licznik_kolumn]==' '){
                    if(((((licznik_wierszy!=0)&&(licznik_wierszy!=wiersze-1))&&(licznik_kolumn!=0))&&(licznik_kolumn!=kolumny))){
                        if((((plansza[licznik_wierszy][licznik_kolumn+1]==' ')&&(plansza[licznik_wierszy][licznik_kolumn-1]==' '))&&
                            (plansza[licznik_wierszy+1][licznik_kolumn]==' '))&&(plansza[licznik_wierszy-1][licznik_kolumn]==' ')){

                                pola_pokarmu[licznik_pol].poz_kolumna=licznik_kolumn;
                                pola_pokarmu[licznik_pol].poz_wiersz=licznik_wierszy;
                                licznik_pol=licznik_pol+1;
                            }
                    }

                }
                licznik_kolumn=licznik_kolumn+1;
            }

        licznik_wierszy=licznik_wierszy+1;
    }
    wybrane_pole= (rand() % licznik_pol);

    int temp;
    temp = (rand() % 100 );
    if(temp<80){
        super=0;
    }else{
        super=1;
    }



    karmaweza.poz_wiersz=pola_pokarmu[wybrane_pole].poz_wiersz;
    karmaweza.poz_kolumna=pola_pokarmu[wybrane_pole].poz_kolumna;

}
//

Teraz chcę dodać planszę 10 najwyższych wyników.

Chodzi o to, że na końcu rozgrywki program ma załadować plik z najwyższymi wynikami, dopisać wynik gracza (i imie wpisane przez gracza), posortować, wyświetlić na ekranie, oraz zapisać w pliku, nadpisując stare dane ( W pliku zawsze ma być 10 wyników i 10 imion). W menu gry będzie też opcja pokazania 10 aktualnych najlepszych wyników.

Przykładowy plik prezentuje się następująco

12|gracz1/
24|gracz2/
56|gracz3/
90|gracz4
122|gracz5/
91|gracz6/
13|gracz7/
99|gracz8/
223|gracz9/
100|gracz10/

| rozdziela wynik od imienia gracza, / rodziela pozycje.

Całość ma się załadować do 2 tablic - int wyniki [11] oraz char imiona [50][11]. (A może tablica struktur...)

Chciałbym zastosować odczyt znak po znaku i taki sam zapis. Nie wiem jak sobie poradzić z tym, że liczby nie są zapisane binarnie, a dziesiętnie jako znaki.

[[C++] busy wait]

[long post]

Dodałem generowanie pokarmu oraz prawie całkowicie usunąłem migotanie poprzez zastosowanie bufora - tablicy.

Co do generowania pokarmu, to mam mały problem. Dla ułatwienia gry chcę, aby pokarm nie generował się na polach bezspośrednio przy ścianach, ale pomimo ifów, tam się generuje (zobacz kod funkcji na końcu kodu).

Dalsze plany to menu główne, pauza, plansza najwyższych wyników, gdzie możnabyłoby wpisać swoje imię (zapis/odczyt do/z pliku) oraz odczyt ciekawszych plansz z plików (bariery na środku planszy ułożone w różne sposoby).

Grać się da, nawet fajnie, gdyż popracowałem nad sterowaniem.

Odnoszę wrażenie, że wraz ze wzrostem długości węża gra chodzi wolniej - czy to złudzenie optyczne?

wstawiam kod

#include <iostream>
#include <ctime>
#include <stdlib.h>
#include <Windows.h>

using namespace std;

//Stale - wielkosc planszy
    const int wiersze = 20;
    const int kolumny = 90;


//Deklaracja struktury segmentu weza;
struct segment
{
    int poz_wiersz;
    int poz_kolumna;
};
//Deklaracja struktury pokarmu do zebrania;
struct pokarm
{
    int poz_wiersz;
    int poz_kolumna;
};

pokarm karmaweza;

//Enumerator - kierunki
enum kierunki{
    gora=0,
    lewo=1,
    dol=2,
    prawo=3,
    escape=9
};


void wyswietl(char plansza[wiersze][kolumny], kierunki wektor);
void pokazweza(segment snake [(wiersze-2)*(kolumny-2)],int dlugosc);//FUNKCJA TYMCZASOWA
int przesunweza(segment snake [(wiersze-2)*(kolumny-2)],int & dlugosc,char plansza[wiersze][kolumny],kierunki wektor, int & punkty);
void aktualizacja(char plansza[wiersze][kolumny],segment snake [(wiersze-2)*(kolumny-2)], int dlugosc);
void generujpokarm(char plansza[wiersze][kolumny]);

int main()
{
    srand( time( NULL ) );
    //waz jako tablica - rownanie wylicza makszymlna dlugosc weza;
    // segment o numerze 0 - glowa, pozostale - segmenty ogona;
    segment snake [(wiersze-2)*(kolumny-2)];
    //dlugosc weza - na poczatku gry glowa i 3 segmenty ogona
    int dlugosc = 4;
    int punkty = 0;

    //ustawianie poczatkowej pozycji weza
    int ustawianie=0;
    while(ustawianie<dlugosc){
        snake[ustawianie].poz_wiersz=1;
        snake[ustawianie].poz_kolumna=dlugosc+1-ustawianie;
        ustawianie=ustawianie+1;
    }


    //plansza gry
    char plansza [wiersze][kolumny];

    int wyswiersze = 0;
    int wyskolumny = 0;

    //===============================================================
    //Wypelnienie planszy
    while(wyswiersze<wiersze){
        while(wyskolumny<kolumny){
            plansza [wyswiersze][wyskolumny]=' ';
            wyskolumny = wyskolumny+1;
        }
        wyswiersze=wyswiersze+1;
        wyskolumny=0;
    }

    wyswiersze = 0;
    wyskolumny = 0;

    //ramka pozioma
    while (wyskolumny<kolumny){
        plansza[0][wyskolumny]= 'X';
        plansza[wiersze-1][wyskolumny]= 'X';
        wyskolumny=wyskolumny+1;
    }

    wyswiersze = 0;
    wyskolumny = 0;

    //ramka pionowa
    while (wyswiersze<wiersze){
        plansza[wyswiersze][0]= 'X';
        plansza[wyswiersze][kolumny-1]='X';
        wyswiersze=wyswiersze+1;
    }


    //Wstawianie weza do tablicy
    ustawianie=0;
    while(ustawianie<dlugosc){
            if(ustawianie==0){
                plansza[snake[ustawianie].poz_wiersz][snake[ustawianie].poz_kolumna]= 'G';
            }else{
                plansza[snake[ustawianie].poz_wiersz][snake[ustawianie].poz_kolumna]= 'O';
            }
        ustawianie=ustawianie+1;
    }

    //===============================================================

    //wyswietlenie planszy;
    cout << "Punkty: " << punkty << "          " << "Dlugosc weza: " << dlugosc<<endl;
    kierunki wektor= prawo;
    generujpokarm(plansza);
    wyswietl(plansza, wektor);



    bool granie = 1;
    float secs=0.1;
    int reakcja;

    while (granie==1){

        clock_t delay = secs * CLOCKS_PER_SEC;
        clock_t start = clock();
        while(clock() - start < delay){
            //Sprawdzenie czy jest nacisniety klawisz
            if(((GetKeyState('W') & 0x8000) && (wektor!=gora)) && (wektor!=dol))
            {
                wektor = gora;
                break;
            }
            if(((GetKeyState('A') & 0x8000) && (wektor!=lewo)) && (wektor!=prawo))
            {
                wektor = lewo;
                break;
            }
            if(((GetKeyState('S') & 0x8000) && (wektor!=dol)) && (wektor!=gora))
            {

                wektor = dol;
                break;
            }
            if(((GetKeyState('D') & 0x8000) && (wektor!=prawo)) && (wektor!=lewo))
            {
                wektor = prawo;
                break;
            }


        }
        reakcja = przesunweza(snake,dlugosc,plansza,wektor,punkty);

        if ((reakcja==0) || (reakcja==2)){
            if(reakcja==2){
                generujpokarm(plansza);
            }
            aktualizacja(plansza,snake,dlugosc);
            system("CLS");
            cout << "Punkty: " << punkty << "          " << "Dlugosc weza: " << dlugosc<<endl;
            wyswietl(plansza, wektor);
        }
        if (reakcja==1){
            granie=0;
        }

    }












    return 0;
}



void wyswietl(char plansza[wiersze][kolumny], kierunki wektor){
    //wyswietlenie planszy;
    int wyswiersze = 0;
    int wyskolumny = 0;
    long wymiartablicy;
    wymiartablicy = (wiersze*(kolumny+2));
    char ekran [wymiartablicy];
    int licznik=0;


    while(wyswiersze<wiersze){
        while(wyskolumny<kolumny){
            if(plansza [wyswiersze][wyskolumny]!='G')
            {
                ekran[licznik]=plansza [wyswiersze][wyskolumny];
            }
            else{
                    if(wektor== gora){
                        ekran[licznik]='A';
                    }
                    if(wektor== lewo){
                        ekran[licznik]='<';
                    }
                    if(wektor== prawo){
                        ekran[licznik]='>';
                    }
                    if(wektor== dol){
                        ekran[licznik]='V';
                    }

            }
            wyskolumny = wyskolumny+1;
            licznik=licznik+1;
        }
        ekran[licznik]='\n';
        licznik=licznik+1;
        wyswiersze=wyswiersze+1;
        wyskolumny=0;
    }
    cout << ekran;

}

void pokazweza(segment snake [(wiersze-2)*(kolumny-2)],int dlugosc){
    int licznik=0;
    while(licznik<dlugosc){
        cout << "==========================================="<<endl;
        if(licznik==0){
            cout <<"GLOWA"<<endl;
        }
        else{
            cout << "SEGMENT no. " << licznik<<endl;
        }
        cout << "-------------------------------------------"<<endl;
        cout << "wartosc zmiennej poz_wiersz = " << snake[licznik].poz_wiersz<<endl;
        cout << "wartosc zmiennej poz_kolumna = " << snake[licznik].poz_kolumna<<endl;

        licznik=licznik+1;
    }

}

int przesunweza(segment snake [(wiersze-2)*(kolumny-2)],int & dlugosc,char plansza[wiersze][kolumny],kierunki wektor, int & punkty){
    int licznik;
    segment glowa;//Przechowuje wspozedne glowy weza
    glowa=snake[0];

    enum wyjscia{
    puste_pole=0,
    pokarm=1,
    sciana=2,//lub ogon
    };
    wyjscia wartosc;

    switch(wektor){
        case gora:
            glowa.poz_wiersz=glowa.poz_wiersz-1;
            break;
        case lewo:
            glowa.poz_kolumna=glowa.poz_kolumna-1;
            break;
        case dol:
            glowa.poz_wiersz=glowa.poz_wiersz+1;
            break;
        case prawo:
            glowa.poz_kolumna=glowa.poz_kolumna+1;
            break;
            }


    //Sprawdzanie na jakie pole jest przesuwana glowa weza
    if (plansza[glowa.poz_wiersz][glowa.poz_kolumna]=='X'){
        wartosc=sciana;
        }else
    if (plansza[glowa.poz_wiersz][glowa.poz_kolumna]=='O'){
        wartosc=sciana;
        }else
    if (plansza[glowa.poz_wiersz][glowa.poz_kolumna]=='p'){
        wartosc=pokarm;
        }else
    if (plansza[glowa.poz_wiersz][glowa.poz_kolumna]==' '){
        wartosc=puste_pole;
        }

    if(wartosc!=2){
        segment tymczasowa [dlugosc+2];
        licznik=0;
        while(licznik<dlugosc){//Kopiuje weza do tablicy tymczasowej
            tymczasowa[licznik]=snake[licznik];

            licznik=licznik+1;
        }
        snake[0]=glowa;
        licznik=1;
        while(licznik<dlugosc){
            snake[licznik]=tymczasowa[licznik-1];
            licznik=licznik+1;
        }
        if(wartosc==1){
            snake[dlugosc]=tymczasowa[dlugosc-1];
            dlugosc=dlugosc+1;
            punkty=punkty+1;
        }
    }

    if (wartosc==2){//Zwraca 2 gdy glowa weza uderza o sciane lub o ogon
        return 1;
    }
    if (wartosc==1){
        return 2;
    }
    return 0;

}

void aktualizacja(char plansza[wiersze][kolumny],segment snake [(wiersze-2)*(kolumny-2)], int dlugosc){
    int wyswiersze = 0;
    int wyskolumny = 0;

    //===============================================================
    //Wypelnienie planszy
    while(wyswiersze<wiersze){
        while(wyskolumny<kolumny){
            plansza [wyswiersze][wyskolumny]=' ';
            wyskolumny = wyskolumny+1;
        }
        wyswiersze=wyswiersze+1;
        wyskolumny=0;
    }

    wyswiersze = 0;
    wyskolumny = 0;

    //ramka pozioma
    while (wyskolumny<kolumny){
        plansza[0][wyskolumny]= 'X';
        plansza[wiersze-1][wyskolumny]= 'X';
        wyskolumny=wyskolumny+1;
    }

    wyswiersze = 0;
    wyskolumny = 0;

    //ramka pionowa
    while (wyswiersze<wiersze){
        plansza[wyswiersze][0]= 'X';
        plansza[wyswiersze][kolumny-1]='X';
        wyswiersze=wyswiersze+1;
    }

    //Wstawianie weza do tablicy
    int ustawianie=0;
    while(ustawianie<dlugosc){
            if(ustawianie==0){
                plansza[snake[ustawianie].poz_wiersz][snake[ustawianie].poz_kolumna]= 'G';
            }else{
                plansza[snake[ustawianie].poz_wiersz][snake[ustawianie].poz_kolumna]= 'O';
            }
        ustawianie=ustawianie+1;
    }
    plansza[karmaweza.poz_wiersz][karmaweza.poz_kolumna]= 'p';



}

void generujpokarm(char plansza[wiersze][kolumny]){
    pokarm karma;

    do{
        do{
            karma.poz_kolumna=rand();
        }while ((karma.poz_kolumna<1 ) || (karma.poz_kolumna>(kolumny-2)));

        do{
            karma.poz_wiersz=rand();
        }while ((karma.poz_wiersz<1 ) || (karma.poz_wiersz>(wiersze-2)));

    }while(plansza[karma.poz_wiersz][karma.poz_kolumna] != ' ');
    karmaweza.poz_wiersz=karma.poz_wiersz;
    karmaweza.poz_kolumna=karma.poz_kolumna;

}
//

I jeszcze jedno pytanie. Mówiłeś, że wolałbyś przechowywać węża jako współrzędne głowy i końcówki ogona - zastanawiam się jak. Wyobraź sobie 2 węże o takich samych współrzędnych głowy i końcówki ogona. Jeden ma kształt litery U, a drugi kształt P w cyrylicy (czyli U odwrócone o 180 stopni). Jak chciałbyś to zrobić.

PS. Przepraszam za strukturę globalną dla wszystkich funkcji.

[[C++] busy wait]

Mam pytanie - czy jako bufor może posłużyć duży napis - tablica, czyli tablica typu char zakończona znakiem NUL? Czy muszę zastosować specjalny typ z jakiejś biblioteki?

 

[[C++] busy wait]

Właśnie skończyłem pisać sterowanie, i już można sterować wężem po planszy.

Pozostaje jeszcze do zrobienia generowanie pokarmu na planszy, ale tu wystarczą 2 liczby pseudolosowe i parę ifów.

Potem dorobię menu i inne "bajery"

Niestety system("cls") miga w czasie pracy programu - można to jakoś obeść?

Wklejam kod

#include <iostream>
#include <ctime>
#include <stdlib.h>
#include <Windows.h>

using namespace std;

//Stale - wielkosc planszy
    const int wiersze = 20;
    const int kolumny = 90;

//Deklaracja struktury segmentu weza;
struct segment
{
    int poz_wiersz;
    int poz_kolumna;
};
//Deklaracja struktury pokarmu do zebrania;
struct pokarm
{
    int poz_wiersz;
    int poz_kolumna;
};

//Enumerator - kierunki
enum kierunki{
    gora=0,
    lewo=1,
    dol=2,
    prawo=3,
    escape=9
};


void wyswietl(char plansza[wiersze][kolumny], kierunki wektor);
void pokazweza(segment snake [(wiersze-2)*(kolumny-2)],int dlugosc);//FUNKCJA TYMCZASOWA
int przesunweza(segment snake [(wiersze-2)*(kolumny-2)],int & dlugosc,char plansza[wiersze][kolumny],kierunki wektor, int & punkty);
void aktualizacja(char plansza[wiersze][kolumny],segment snake [(wiersze-2)*(kolumny-2)], int dlugosc);

int main()
{
    //waz jako tablica - rownanie wylicza makszymlna dlugosc weza;
    // segment o numerze 0 - glowa, pozostale - segmenty ogona;
    segment snake [(wiersze-2)*(kolumny-2)];
    //dlugosc weza - na poczatku gry glowa i 3 segmenty ogona
    int dlugosc = 4;
    int punkty = 0;

    //ustawianie poczatkowej pozycji weza
    int ustawianie=0;
    while(ustawianie<dlugosc){
        snake[ustawianie].poz_wiersz=1;
        snake[ustawianie].poz_kolumna=dlugosc+1-ustawianie;
        ustawianie=ustawianie+1;
    }


    //plansza gry
    char plansza [wiersze][kolumny];

    int wyswiersze = 0;
    int wyskolumny = 0;

    //===============================================================
    //Wypelnienie planszy
    while(wyswiersze<wiersze){
        while(wyskolumny<kolumny){
            plansza [wyswiersze][wyskolumny]=' ';
            wyskolumny = wyskolumny+1;
        }
        wyswiersze=wyswiersze+1;
        wyskolumny=0;
    }

    wyswiersze = 0;
    wyskolumny = 0;

    //ramka pozioma
    while (wyskolumny<kolumny){
        plansza[0][wyskolumny]= 'X';
        plansza[wiersze-1][wyskolumny]= 'X';
        wyskolumny=wyskolumny+1;
    }

    wyswiersze = 0;
    wyskolumny = 0;

    //ramka pionowa
    while (wyswiersze<wiersze){
        plansza[wyswiersze][0]= 'X';
        plansza[wyswiersze][kolumny-1]='X';
        wyswiersze=wyswiersze+1;
    }


    //Wstawianie weza do tablicy
    ustawianie=0;
    while(ustawianie<dlugosc){
            if(ustawianie==0){
                plansza[snake[ustawianie].poz_wiersz][snake[ustawianie].poz_kolumna]= 'G';
            }else{
                plansza[snake[ustawianie].poz_wiersz][snake[ustawianie].poz_kolumna]= 'O';
            }
        ustawianie=ustawianie+1;
    }

    //===============================================================

    //wyswietlenie planszy;
    cout << "Punkty: " << punkty << "          " << "Dlugosc weza: " << dlugosc<<endl;
    kierunki wektor= prawo;
    wyswietl(plansza, wektor);




    bool granie = 1;
    float secs=0.1a;
    int reakcja;

    while (granie==1){

        clock_t delay = secs * CLOCKS_PER_SEC;
        clock_t start = clock();
        while(clock() - start < delay){
            //Sprawdzenie czy jest nacisniety klawisz
            if((GetKeyState('W') & 0x8000) && (wektor!=gora))
            {
                wektor = gora;
                break;
            }
            if((GetKeyState('A') & 0x8000) && (wektor!=lewo))
            {
                wektor = lewo;
                break;
            }
            if((GetKeyState('S') & 0x8000) && (wektor!=dol))
            {

                wektor = dol;
                break;
            }
            if((GetKeyState('D') & 0x8000) && (wektor!=prawo))
            {
                wektor = prawo;
                break;
            }


        }
        reakcja = przesunweza(snake,dlugosc,plansza,wektor,punkty);
        if (reakcja==0){

            aktualizacja(plansza,snake,dlugosc);
            system("CLS");
            cout << "Punkty: " << punkty << "          " << "Dlugosc weza: " << dlugosc<<endl;
            wyswietl(plansza, wektor);
        }
        if (reakcja==1){
            granie=0;
        }
    }












    return 0;
}



void wyswietl(char plansza[wiersze][kolumny], kierunki wektor){
    //wyswietlenie planszy;
    int wyswiersze = 0;
    int wyskolumny = 0;

    while(wyswiersze<wiersze){
        while(wyskolumny<kolumny){
            if(plansza [wyswiersze][wyskolumny]!='G')
            {
                printf("%c", plansza [wyswiersze][wyskolumny]);
            }
            else{
                    if(wektor== gora){
                        printf ("A");
                    }
                    if(wektor== lewo){
                        printf ("<");
                    }
                    if(wektor== prawo){
                        printf (">");
                    }
                    if(wektor== dol){
                        printf ("V");
                    }

            }
            wyskolumny = wyskolumny+1;
        }
        cout << endl;
        wyswiersze=wyswiersze+1;
        wyskolumny=0;
    }

}

void pokazweza(segment snake [(wiersze-2)*(kolumny-2)],int dlugosc){
    int licznik=0;
    while(licznik<dlugosc){
        cout << "==========================================="<<endl;
        if(licznik==0){
            cout <<"GLOWA"<<endl;
        }
        else{
            cout << "SEGMENT no. " << licznik<<endl;
        }
        cout << "-------------------------------------------"<<endl;
        cout << "wartosc zmiennej poz_wiersz = " << snake[licznik].poz_wiersz<<endl;
        cout << "wartosc zmiennej poz_kolumna = " << snake[licznik].poz_kolumna<<endl;

        licznik=licznik+1;
    }

}

int przesunweza(segment snake [(wiersze-2)*(kolumny-2)],int & dlugosc,char plansza[wiersze][kolumny],kierunki wektor, int & punkty){
    int licznik;
    segment glowa;//Przechowuje wspozedne glowy weza
    glowa=snake[0];

    enum wyjscia{
    puste_pole=0,
    pokarm=1,
    sciana=2,//lub ogon
    };
    wyjscia wartosc;

    switch(wektor){
        case gora:
            glowa.poz_wiersz=glowa.poz_wiersz-1;
            break;
        case lewo:
            glowa.poz_kolumna=glowa.poz_kolumna-1;
            break;
        case dol:
            glowa.poz_wiersz=glowa.poz_wiersz+1;
            break;
        case prawo:
            glowa.poz_kolumna=glowa.poz_kolumna+1;
            break;
            }


    //Sprawdzanie na jakie pole jest przesuwana glowa weza
    if (plansza[glowa.poz_wiersz][glowa.poz_kolumna]=='X'){
        wartosc=sciana;
        }else
    if (plansza[glowa.poz_wiersz][glowa.poz_kolumna]=='O'){
        wartosc=sciana;
        }else
    if (plansza[glowa.poz_wiersz][glowa.poz_kolumna]=='p'){
        wartosc=pokarm;
        }else
    if (plansza[glowa.poz_wiersz][glowa.poz_kolumna]==' '){
        wartosc=puste_pole;
        }

    if(wartosc!=2){
        segment tymczasowa [dlugosc+2];
        licznik=0;
        while(licznik<dlugosc){//Kopiuje weza do tablicy tymczasowej
            tymczasowa[licznik]=snake[licznik];

            licznik=licznik+1;
        }
        snake[0]=glowa;
        licznik=1;
        while(licznik<dlugosc){
            snake[licznik]=tymczasowa[licznik-1];
            licznik=licznik+1;
        }
        if(wartosc==1){
            snake[dlugosc]=tymczasowa[dlugosc-1];
            dlugosc=dlugosc+1;
            punkty=punkty+1;
        }
    }

    if (wartosc==2){//Zwraca 2 gdy glowa weza uderza o sciane lub o ogon
        return 1;
    }
    return 0;

}

void aktualizacja(char plansza[wiersze][kolumny],segment snake [(wiersze-2)*(kolumny-2)], int dlugosc){
    int wyswiersze = 0;
    int wyskolumny = 0;

    //===============================================================
    //Wypelnienie planszy
    while(wyswiersze<wiersze){
        while(wyskolumny<kolumny){
            plansza [wyswiersze][wyskolumny]=' ';
            wyskolumny = wyskolumny+1;
        }
        wyswiersze=wyswiersze+1;
        wyskolumny=0;
    }

    wyswiersze = 0;
    wyskolumny = 0;

    //ramka pozioma
    while (wyskolumny<kolumny){
        plansza[0][wyskolumny]= 'X';
        plansza[wiersze-1][wyskolumny]= 'X';
        wyskolumny=wyskolumny+1;
    }

    wyswiersze = 0;
    wyskolumny = 0;

    //ramka pionowa
    while (wyswiersze<wiersze){
        plansza[wyswiersze][0]= 'X';
        plansza[wyswiersze][kolumny-1]='X';
        wyswiersze=wyswiersze+1;
    }

    //Wstawianie weza do tablicy
    int ustawianie=0;
    while(ustawianie<dlugosc){
            if(ustawianie==0){
                plansza[snake[ustawianie].poz_wiersz][snake[ustawianie].poz_kolumna]= 'G';
            }else{
                plansza[snake[ustawianie].poz_wiersz][snake[ustawianie].poz_kolumna]= 'O';
            }
        ustawianie=ustawianie+1;
    }



}

 

[[C++] busy wait]

Poprzerabiałem trochę prototyp sterowania wzorując się na tym:

https://stackoverflow.com/questions/41600981/how-do-i-check-if-a-key-is-pressed-on-c/41601909

Cytat

As mentioned by others there's no cross platform way to do this, but on Windows you can do it like this:

The Code below checks if the key 'A' is down.

if(GetKeyState('A') & 0x8000/*Check if high-order bit is set (1 << 15)*/)
{
    // Do stuff
}

In case of shift or similar you will need to pass one of these: https://msdn.microsoft.com/de-de/library/windows/desktop/dd375731(v=vs.85).aspx

if(GetKeyState(VK_SHIFT) & 0x8000)
{
    // Shift down
}

The low-order bit indicates if key is toggled.

SHORT keyState = GetKeyState(VK_CAPITAL/*(caps lock)*/);
bool isToggled = keyState & 1;
bool isDown = keyState & 0x8000;

Oh and also don't forget to

#include <Windows.h>

Autor wypowiedzi:Frank S.

 

Zatem: Zrobiłem coś takiego:

#include <iostream>
#include <ctime>
#include <Windows.h>
int main()
{
    using namespace std;
    while(1){
    float secs;
    int kod_klawisza=0;
    secs=5;
    clock_t delay = secs * CLOCKS_PER_SEC;
    clock_t start = clock();
    while(clock() - start < delay){
        //Sprawdzenie czy jest nacisniety klawisz
    if(GetKeyState('W') & 0x8000)
    {
        cout << "Nacisnieto klawisz W";
        kod_klawisza =1;
        break;
    }
    if(GetKeyState('A') & 0x8000)
    {
        cout << "Nacisnieto klawisz A";
        kod_klawisza =2;
        break;
    }
    if(GetKeyState('S') & 0x8000)
    {
        cout << "Nacisnieto klawisz S";
        kod_klawisza =3;
        break;
    }
    if(GetKeyState('D') & 0x8000)
    {
        cout << "Nacisnieto klawisz D";
        kod_klawisza =4;
        break;
    }
    }
    cout<< "\ngotowe \n\a";

    switch(kod_klawisza){
        case 1:{
        cout << "W";
        break;
        }
        case 2:{
        cout << "A";
        break;
        }
        case 3:{
        cout << "S";
        break;
        }
        case 4:{
        cout << "D";
        break;
        }


    }
    }
    return 0;



}

 

Jeżeli jest to możliwe to przerobię to na funkcję zwracającą kod, na podstawie którego będzie zmiana wektora węża lub wyjście z gry. Jeżeli nie można tego przerobić na funkcję to wstawie coś w tym stylu do maina.

PS. Tak, wiem pętle nie zaznaczone, ale to prototyp.

 

Niestety wykorzystuje bibliotekę windows.h, zatem niestety nie jest to rozwiązanie przenośne. Ale i tak najpewniej zastosuję system ("cls") do czyszczenia konsoli.

[[C++] busy wait]

 

Zmodyfikowałem trochę funkcje przesuwającą węża.

int przesunweza(segment snake [(wiersze-2)*(kolumny-2)],int * dlugosc,char plansza[wiersze][kolumny],kierunki wektor, int * punkty){
    int licznik;
    segment glowa;//Przechowuje wspozedne glowy weza
    glowa=snake[0];

    enum wyjscia{
    puste_pole=0,
    pokarm=1,
    sciana=2,//lub ogon
    };
    wyjscia wartosc;

    switch(wektor){
        case gora:
            glowa.poz_wiersz=glowa.poz_wiersz-1;
            break;
        case lewo:
            glowa.poz_kolumna=glowa.poz_kolumna-1;
            break;
        case dol:
            glowa.poz_wiersz=glowa.poz_wiersz+1;
            break;
        case prawo:
            glowa.poz_kolumna=glowa.poz_kolumna+1;
            break;
            }


    //Sprawdzanie na jakie pole jest przesuwana glowa weza
    if (plansza[glowa.poz_wiersz][glowa.poz_kolumna]=='X'){
        wartosc=sciana;
        }else
    if (plansza[glowa.poz_wiersz][glowa.poz_kolumna]=='O'){
        wartosc=sciana;
        }else
    if (plansza[glowa.poz_wiersz][glowa.poz_kolumna]=='p'){
        wartosc=pokarm;
        }else
    if (plansza[glowa.poz_wiersz][glowa.poz_kolumna]==' '){
        wartosc=puste_pole;
        }

    if(wartosc!=2){
        segment tymczasowa [*dlugosc+2];
        licznik=0;
        while(licznik<*dlugosc){//Kopiuje weza do tablicy tymczasowej
            tymczasowa[licznik]=snake[licznik];

            licznik=licznik+1;
        }
        snake[0]=glowa;
        licznik=1;
        while(licznik<*dlugosc){
            snake[licznik]=tymczasowa[licznik-1];
            licznik=licznik+1;
        }
        if(wartosc==1){
            snake[*dlugosc]=tymczasowa[*dlugosc-1];
            *dlugosc=*dlugosc+1;
            *punkty=*punkty+1;
        }
    }

    if (wartosc==2){//Zwraca 2 gdy glowa weza uderza o sciane lub o ogon
        return 1;
    }
    return 0;

}

 

Oprócz tego zastanawiam się, nad użyciem do sterowania czegoś takiego - na razie mam szkielet - potrzebuję funkji sprawdzającej czy jest naciśnięty klawisz:

Ma to wyglądać mniej więcej tak:

using namespace std;
    float secs;
    int kod_klawisza;
    secs=czas oczekiwania;
    clock_t delay = secs * CLOCKS_PER_SEC;
    clock_t start = clock();
    while(clock() - start < delay)
        //Sprawdzenie czy jest nacisniety klawisz
    if (klawisz jest nacisniety){
        kod_klawisza= //kod odczytanego klawisza;
        //czyszczenie bufora klawiszy
        break;
    }

 

PS. Ten kod powyżej to lekko zmodyfikowana modelowa pętla oczekująca z podręcznika.

[[C++] busy wait]

Funkcji oczekiwania i sprawdzania czy jakiś klawisz jest naciśnięty jeszcze nie mam.

Za to zrobiłem funkcję "testową" wypisującą współrzędne segmentów węża oraz funkcję przesuwania węża.

Funkcja testowa:

	void pokazweza(segment snake [(wiersze-2)*(kolumny-2)],int dlugosc){
    int licznik=0;
    while(licznik<dlugosc){
        cout << "==========================================="<<endl;
        if(licznik==0){
            cout <<"GLOWA"<<endl;
        }
        else{
            cout << "SEGMENT no. " << licznik<<endl;
        }
        cout << "-------------------------------------------"<<endl;
        cout << "wartosc zmiennej poz_wiersz = " << snake[licznik].poz_wiersz<<endl;
        cout << "wartosc zmiennej poz_kolumna = " << snake[licznik].poz_kolumna<<endl;
	        licznik=licznik+1;
    }
	}
	

Funkcja przesuwająca:

	int przesunweza(segment snake [(wiersze-2)*(kolumny-2)],int * dlugosc,char plansza[wiersze][kolumny],kierunki wektor, int * punkty){
    int licznik;
    segment tymczasowa [*dlugosc+2];
    while(licznik<*dlugosc){//Kopiuje weza do tablicy tymczasowej
        tymczasowa[licznik].poz_kolumna=snake[licznik].poz_kolumna;
        tymczasowa[licznik].poz_wiersz=snake[licznik].poz_wiersz;
        licznik=licznik+1;
    }
    enum wyjscia{
    puste_pole=0,
    pokarm=1,
    sciana=2,//lub ogon
    };
    wyjscia wartosc;
    switch(wektor){
        case gora:
            snake[0].poz_wiersz=snake[0].poz_wiersz-1;
            if (plansza[snake[0].poz_wiersz][snake[0].poz_kolumna]=='X'){
                wartosc=sciana;
                break;
            }
            if (plansza[snake[0].poz_wiersz][snake[0].poz_kolumna]=='O'){
                wartosc=sciana;
                break;
            }
            if (plansza[snake[0].poz_wiersz][snake[0].poz_kolumna]=='p'){
                wartosc=pokarm;
            }
            if (plansza[snake[0].poz_wiersz][snake[0].poz_kolumna]==' '){
                wartosc=puste_pole;
            }
            break;
        case lewo:
            snake[0].poz_kolumna=snake[0].poz_kolumna-1;
            if (plansza[snake[0].poz_wiersz][snake[0].poz_kolumna]=='X'){
                wartosc=sciana;
                break;
            }
            if (plansza[snake[0].poz_wiersz][snake[0].poz_kolumna]=='O'){
                wartosc=sciana;
                break;
            }
            if (plansza[snake[0].poz_wiersz][snake[0].poz_kolumna]=='p'){
                wartosc=pokarm;
            }
            if (plansza[snake[0].poz_wiersz][snake[0].poz_kolumna]==' '){
                wartosc=puste_pole;
            }
            break;
        case dol:
            snake[0].poz_wiersz=snake[0].poz_wiersz+1;
            if (plansza[snake[0].poz_wiersz][snake[0].poz_kolumna]=='X'){
                wartosc=sciana;
                break;
            }
            if (plansza[snake[0].poz_wiersz][snake[0].poz_kolumna]=='O'){
                wartosc=sciana;
                break;
            }
            if (plansza[snake[0].poz_wiersz][snake[0].poz_kolumna]=='p'){
                wartosc=pokarm;
            }
            if (plansza[snake[0].poz_wiersz][snake[0].poz_kolumna]==' '){
                wartosc=puste_pole;
            }
            break;
        case prawo:
            snake[0].poz_kolumna=snake[0].poz_kolumna+1;
            if (plansza[snake[0].poz_wiersz][snake[0].poz_kolumna]=='X'){
                wartosc=sciana;
                break;
            }
            if (plansza[snake[0].poz_wiersz][snake[0].poz_kolumna]=='O'){
                wartosc=sciana;
                break;
            }
            if (plansza[snake[0].poz_wiersz][snake[0].poz_kolumna]=='p'){
                wartosc=pokarm;
            }
            if (plansza[snake[0].poz_wiersz][snake[0].poz_kolumna]==' '){
                wartosc=puste_pole;
            }
            break;
            }
	            if (wartosc==2){//Zwraca 2 gdy glowa weza uderza o sciane lub o ogon
                return 1;
            }
            licznik=1;
            while(licznik<*dlugosc){
                snake[licznik]=tymczasowa[licznik-1];
                licznik=licznik+1;
            }
            if(wartosc==1){
                snake[*dlugosc]=tymczasowa[*dlugosc-1];
                *dlugosc=*dlugosc+1;
                *punkty=*punkty+1;
            }
            return 0;
	}

PS: W nagłówki (przed mainem i prototypami funkcji) mam taki enumerator:

	//Enumerator - kierunki
enum kierunki{
    gora=0,
    lewo=1,
    dol=2,
    prawo=3
};

Jakbyś chciał, to mogę wstawić na forum całą obecną treść pliku - uwaga nie ma jeszcze nawet głównej pętli gry, ale może chciałbyś zobaczyć jak zrobiona jest tablica - plansza?

Co sądzisz o moich funkcjach?

[[C++] busy wait]

Zapomniałem napisać w dzisiejszym poście, że długość węża określa zmienna w maine.

Tak, wiem, że struktura określająca położenie pokarmu także mogłaby być typu segment.

V

V

V

Moim największym probleme jest obecnie jednak ta nieszczęsn funkcja zwracająca naciśnięty klawisz. kbhit()  chyba się nie nadaje, bo mi nie działa. Funkcja nie ma czekać na naciśnięcie, ale ma sprawdzić, czy w danym momencie jest naciśnięty klawisz/klawszie i wydać jaki/jakie - w tym przypadku wystarczy 1 klawisz. Być może okaże się konieczna też funkcja czyszcząca bufor klawiszy. (Czy cin.clear się nada?)

[[C++] busy wait]

W dniu 20.09.2020 o 12:11, Bono[UG] napisał:

Z tego opisu wygląda, że im szybciej będzie się wciskać klawisze, tym szybciej gra będzie chodziła. Czy to zamierzony efekt?
Nie jest to ani dobre ani złe, po prostu taka będzie właściwość gry.

Tak, właśnie chcę taką właściwość.

Co do struktury węża jest to zrobione tak:

	//Przed mainem
	//Deklaracja struktury segmentu weza;
struct segment
{
    int poz_wiersz;
    int poz_kolumna;
};
//Deklaracja struktury pokarmu do zebrania;
struct pokarm
{
    int poz_wiersz;
    int poz_kolumna;
};
	 
	======================================
	 
	//Już w maine
	//waz jako tablica - rownanie wylicza makszymlna dlugosc weza;
    // segment o numerze 0 - glowa, pozostale - segmenty ogona;
    segment snake [(wiersze-2)*(kolumny-2)];
	

 

Równanie wylicza maksymalną długość węża - zobacz.

	//Stale - wielkosc planszy
    const int wiersze = 20;
    const int kolumny = 90;
	

Po tym kodzie znaki w tablicy char plansza [wiersze][kolumny]; w pętli ustawiane są na spacje a potem pierszy i ostatni wiersz oraz pierwsza i ostatnia kolumna są ustawiane na X jako ściany.

 

[edit]

Właśnie chcę funkcję, która sprawdzi czy w danym momencie naciśnięty jest klawisz, i jeżeli tak, to zwróci jego numer identyfikacyjny. Jeżeli nie strzałki, to może WASD.

I jescze jedna, która opróżni bufor klawiszy.

PS. A tzw. wirtualne kody klawiszy ?

Jeszcze raz o wężu. Wiem, że nie jest to najefektywniejsza metoda, ale łatwo ją zaprogramować, wystarczy pętla. Co jest w tej metodzie reprezentowania węża złego?

[[C++] busy wait]

========

long post

========

No cóż...

5 godzin temu, Bono[UG] napisał:

Bo stoi na "getch()", czeka na wciśniecie klawisza.

No właśnie mi chodzi o sposób taki, żeby nie czekało, tylko żeby przy każdej iteracji pętli opóźniającej sprawdzało, czy nie jest naciśnięty klawisz, i jeżeli jest naciśnięta któraś ze strzałek lub ESC to wtedy ma wychodzić z pętli opóźniającej i zmieniać zmienną sterującą / wychodzić z gry.

Opisze algorytm (samej gry, bez menu, etc) jeszcze raz, w inny sposób.

====================================

Początek pętli gry {

Zaktualizuj i  wyświetl planszę

Zacznij liczyć czas

Rozpocznij pętlę oczekującą{

Sprawdź czy nie jest naciśnięty klawisz

Jeżeli jest naciśnięty ESC to wyjdź z gry

Jeżeli jest naciśnięta strzałka to zmień zmienną sterującą wężem ORAZ wyjdź z pętli opóźniacjącej <- tutaj może być goto

zaktualizuj liczenie czasu

zakończ pętlę oczekującą}

Wywołaj funkcję przesunięcia węża (argumenty - tablica struktur segmentów węża, długość węża, plansza jako tablica liczb char, zmienna sterująca wężem, licznik punktów)[

Sprawdź jake jest pole na które zostanie przesunięta głowa

Przekopiuj współrzędne segmentów węża do tablicy tymczasowej

Jeżeli pole do przesunięcia głowy jest ścianą LUB innym segmentem węża to wyjdź z gry i wyświetl plansze "KONIEC GRY" z wynikiem

Jeżeli pole do przesunięcia głowy jest puste to przesuń tam głowę, przesuń segment 1 na poz. głowy, segment 2 na poz. segmentu 1, etc do końca węża, zwiększ licznik punktów

Jeżeli pole do przesunięcia głowy jest polem z pokarmem to przesuń tam głowę, przesuń segment 1 na poz. głowy, segment 2 na poz. segmentu 1, etc do końca węża ORAZ dodaj nowy segment o starej pozycji ostatniego segmentu i zwiększ zmienną określającą długość węża o  i zwiększ licznik punktów}

]

W tej funkcji do przesuwania węża to chyba argumenty będą musiały być wskaźnikami, aby operować na tych samych zmiennych a nie tworzyć lokalne, no chyba, że zrobię zmienne statyczne poza mainem dla całego programu.

Jabyś nie rozumiał, to mogę to napisać w pseudokodzi a'la stare BAISCi czyli onumerować wszystko i zrobić przejścia do konkretnych numerów (to nieszczęsne goto). To co jest w kańciastych nawiasach to opis funkcji przesuwającej węża.

 

PS. W jednej z książek Praty to jest taki cytat, że goto to "Pole nieograniczonych nadużyć", a w innej autor napisał, że uchodzi powszechnie za brzydkie i brudne rozwiązanie.

A co do switch, to jak tam są różne warunki (case) to jak np. są 4 i pozycja aktywna przejdzie do 2 to wykona także 3, 4 (?) i chyba można tam wsadzić break.

Co do obiektowości, jeszcze do niej nie doszedłem, ale wiem, że możliwości ma super.

[Mam cichą nadzieję, że forum się nie "rozjedzie" tak długim postem]

[EDIT] W tych samych podręcznikach jest mowa, że goto może zostać wykorzystane do wychodzenia z bardzo głęboko zakorzenionych pętli.

 

[[C++] busy wait]

Co do tego "szaleje" to chyba się pomyliłem, bo wstawiłem w pętli podbijanie licznika i wypisywanie go na konsolę i zawaliło cały ekran cyframi... Ale to dlatego, że w sekundzie jest duże jednostek czsu (TICS_PER_SEC). Może to była pętla "nieskończona" - jutro sprawdzę.

Kod który wkleiłem na forum daje czarną konsolę i nie wyświetla licznika.

Ogólnie to chcę zrobić grę w "węża" - tzw. "snake" w konsoli (ASCI-art).

Będzie pętla i zmienna opisująca kierunek ruchu węża. Gdy użytkownik naciśnie klawisz wywołana zostanie określona akcja - strałki zmiana zmiennej opisującej kierunek ruchu węża i wyjście z pętli opóźnienia, -esc wyjście z programu. Gdy upłynie czas to nie jest zmieniany kierunek ruchu.

Samo przesunięcię węża to będzie funkcja wstawiona ZA pętlą busy wait. - Pierw kopiowanie tablicy struktur węża, a następnie przesunięcie głowy i zmiana lokalizacji elementów ogona - tj. element o indeksie 1 otrymuje lokalizaje głowy, element o indeksie 2 otrzymuje lokalizację elementu o indeksie 1 itd. aż do końca ogona. Gdy w poprzedniej iteracji pętli wąż zjadł pokarm to dodawany jest kolejny segment o starej lokalizacji ostatniego segmentu. Mówiąc lokalizajca mam na myśli współrzędne (zobacz opis węża poniżej).

Waż to tablica struktur. Bardzo prostych, w każdej strukturze są 2 zmienne int - lokalizacja segmentu w pionie i w poziomie. Element o indeksie 0 w tablicy to głowa, pozostałe to segmenty ogona. Identycznie prezentuje się struktura opisująca pokarm węża.

Goto można tutaj chyba zastąpić zestawem switch - break (?)

[[C++] busy wait]

Wiatm.

Uczę się C++ i potrzebuję tzw. busy wait.

Algorytm ma wyglądać następująco - taki jakby pseudokod:

 

rozpocznij licznie czasu

Jeżeli nie upłynął określony czas{

sprawdź czy dany klawisz nie jest wciśnięty

//tutaj switch lub zestaw ifów dla różnych klawiszy i goto do wyskoczenia z pętli

zaktualizuj liczenie czasu.

}

gdy czas upłynął wykonaj domyślną opcję i kontynuj program dalej.

 

Niestety pętla oczekująca z ctime okazuje się tutaj bezużyteczna ( nie można nic wstawić do pętli bo szaleje).

Zastosowanie sleep też nie działa (zobacz poniżej)

	//niedziala.cpp
	#include <iostream>
#include <unistd.h>
#include <conio.h>
int main()
{
    using namespace std;
    int licznik =0;
    while(licznik < 100){
        sleep (10);
        if (getch () == 27){
            goto koncowka;
        }
        licznik=licznik+1;
        cout << licznik;
    }
    koncowka:
    return 0;
}
	

kompilator codeblocks

 

[[problem] tylko połowa pamięci dostępna]

^Bardzo dobry pomysł. Mam tylko pytanie - czy w mojej płycie będzie potrzebna aktualizacja BIOSu (BIOS jest z 2018 roku)?

[edit] Mam takie pytanie dotyczące radiatorów (odpromienników ciepła) na kościach RAM. Polecane przez Pana kości radiatora nie mają, a moje obecne mają. Czy ten radiator jest potrzebny, czy to tylko bajer? Pytam bo kiedyś wogóle nie było RAMów z radiatorami. Czy te szybkie pamięci się grzeją, czy to tylko bajer?

[[problem] tylko połowa pamięci dostępna]

Znalazłem takie coś:

https://allegro.pl/oferta/g-skill-32gb-aegis-gskill-ddr4-3000mhz-2x16gb-dual-8629955539

model F4-3000C16D-32GISB

Cena atrakcyjna, jak za 32 gigabajty. Tych pamięci nie ma na liście, ale jest na niej model F4-3000C16D-16GISB (może to model bliźniaczy?) - czy ta pamięć z allegro będzie pasować?

PS. Czy warto iść w 32 GB czy lepiej zostać przy 16 GB? Ile warta jest moja obecna pamięć na rynku wtórnym?

 

[[problem] tylko połowa pamięci dostępna]

^Odświeżam. Ktoś pomoże?

[przepraszam za double post]

 

[[problem] tylko połowa pamięci dostępna]

Co do wyłączenia XMP to w BIOSie płyty w ai tweaker -> ai overclock tuner są opcje auto i DOCP czy coś w tym stylu. (wybrane jest auto). Nie ma tam XMP, co jest dziwne, bo np. tutaj na screenshotach z innej płyty Asusowej są:

https://pclab.pl/art80487-3.html

PS. Wiedziałem, że Ryzen lubi szybkie pamięci, ale nie wiedziałem, że aż tak szybkie.

Na dole ekranu BIOS podaje copyright 2018.