Problem z IF-dziwny
Logowanie
Panel użytkownika
Nazwa użytkownika:
Hasło:
Nie masz jeszcze konta?
Zapomniałem hasła
» Forum » Programowanie » [C, C++] Szukam pomocy

Problem z IF-dziwny

Ostatnio zmodyfikowano 2009-06-25 08:09
Autor Wiadomość
Myslivius
Temat założony przez niniejszego użytkownika
Problem z IF-dziwny
» 2009-06-22 18:07:32
Mój problem polega na tym, że w moim kodzie gdy umieszczę instrukcję warunkową IF(kod podany niżej, chociaż niewiele to zmienia), to mimo że warunek jest na pewno nieprawdziwy, to po odpaleniu program się nie włącza i pojawia się ten błąd z "nie wysyłaj" do klikninięcia. A jeżeli wytnę tą instrukcję z kodu, to program działa normalnie.

C/C++
if( stan_menu == M_WCZYTAJ_MAPE )
{
    std::fstream plik( & nazwa_mapy[ 0 ], std::ios::in );
    plik >> txt;
    //INTERPRETACJA PLIKU (bufora "txt")
    char bufor_m;
    int licznik_m = 0;
    int licznik_c = 0;
    int licznik_l = 0;
    std::string mapa_s[ 500 ][ 500 ];
    //wczytywanie do listy plików nazw i numerów plików
    do
    {
        do
        {
            bufor_m = txt[ licznik_c ];
            ++licznik_c;
            if( bufor_m == ',' ) break;
           
            lista_uzytych_plikow_bmp[ licznik_l ].nazwa += bufor_m;
            lista_uzytych_plikow_bmp[ licznik_l ].numer = licznik_l;
        } while( 1 != 2 );
       
        ++licznik_l;
    } while( txt[ licznik_c ] != '|' );
    //czyszczenie mapy_s
    for( int v = 0; v < 500; ++v )
    for( int b = 0; b < 500; ++b )
         mapa_s[ v ][ b ] = "";
    //wczytywanie do mapy numerów plików
    do
    {
        for( int v = 0; v < 500; ++v )
        for( int b = 0; b < 500; ++b )
        {
            do
            {
                bufor_m = txt[ licznik_c ];
                ++licznik_c;
                if( bufor_m == ',' ) break;
               
                mapa_s[ v ][ b ] += bufor_m;
            } while( 1 != 2 );
           
        }
        for( int v = 0; v < 500; ++v )
        for( int b = 0; b < 500; ++b )
        {
            mapa[ v ][ b ].numer_pliku = atoi( mapa_s[ v ][ b ].c_str() );
        }
    } while( txt[ licznik_c ] != '|' );
    //czyszczenie mapy_s
    for( int v = 0; v < 500; ++v )
    for( int b = 0; b < 500; ++b )
         mapa_s[ v ][ b ] = "";
    //wczytywanie do mapy kolizji
    do
    {
        for( int v = 0; v < 500; ++v )
        for( int b = 0; b < 500; ++b )
        {
            do
            {
                bufor_m = txt[ licznik_c ];
                ++licznik_c;
                if( bufor_m == ',' ) break;
               
                mapa_s[ v ][ b ] += bufor_m;
            } while( 1 != 2 );
           
        }
        for( int v = 0; v < 500; ++v )
        for( int b = 0; b < 500; ++b )
        {
            mapa[ v ][ b ].kolizja = atoi( mapa_s[ v ][ b ].c_str() );
        }
    } while( txt[ licznik_c ] != '|' );
    //czyszczenie mapy_s
    for( int v = 0; v < 500; ++v )
    for( int b = 0; b < 500; ++b )
         mapa_s[ v ][ b ] = "";
    //wczytywanie do mapy numerów bitmap (".warstwa")
    do
    {
        for( int v = 0; v < 500; ++v )
        for( int b = 0; b < 500; ++b )
        {
            do
            {
                bufor_m = txt[ licznik_c ];
                ++licznik_c;
                if( bufor_m == ',' ) break;
               
                mapa_s[ v ][ b ] += bufor_m;
            } while( 1 != 2 );
           
        }
        for( int v = 0; v < 500; ++v )
        for( int b = 0; b < 500; ++b )
        {
            mapa[ v ][ b ].warstwa = atoi( mapa_s[ v ][ b ].c_str() );
        }
    } while( txt[ licznik_c ] != '|' );
   
}
P-7902
malan
» 2009-06-22 19:44:19
Jeżeli dobrze Cie zrozumiałem to, jeśli wstawisz do programu ten warunek if (stan_menu==M_WCZYTAJ_MAPE) to program się wywala, tak? 
P-7908
pekfos
» 2009-06-22 19:51:26
jak wycinasz tą instrukcję z kodu.. razem z blokiem funkcji?
C/C++
std::fstream plik( & nazwa_mapy[ 0 ], std::ios::in );
plik >> txt;
odwołanie do nieistniejącego pliku może wywołać ten błąd
sprawdź to:
C/C++
std::fstream plik( & nazwa_mapy[ 0 ], std::ios::in );
if( plik.good() ) {
    plik >> txt;
    //..
P-7911
Myslivius
Temat założony przez niniejszego użytkownika
» 2009-06-22 20:08:32
W tym problem, że błąd nie leży w środku instrukcji, bo nawet jeżeli warunek zmienię na if(1==2), czyli, że nigdy nie włączą się zawarte w tym if'ie instrukcje, to program i tak wywala na samym początku, zanim cokolwiek się pojawi na ekranie. Natomiast jeżeli wytnę cały blok if (wszystko, razem z warunkiem), to cały program działa ok.
P-7914
malan
» 2009-06-22 20:43:09
std::fstream plik( & nazwa_mapy[ 0 ], std::ios::in );
 Co to jest nazwa_mapy[0], tzn. jaki typ zmiennej? Jeśli to string to chyba to powinno wyglądać tak:
std::fstream plik( nazwa_mapy.c_str(), std::ios::in );
 Chyba że to jakaś tablica...
P-7922
Myslivius
Temat założony przez niniejszego użytkownika
» 2009-06-22 20:54:57
Dla mnie też to dziwnie wygląda(na necie ktoś tak napisał), ale napewno działa, bo przy funkcji zapisu, która działa poprawnie jest tak samo. nazwa_mapy, to string, ale do stringa można się odnosić jak do tablicy charów.
Zresztą właśnie poprawiłem na twoją wersję (c.str()), bo tak ładniej wyglada :p, ale i tak nic to nie zmienia.
P-7923
malan
» 2009-06-22 21:13:42
Hmmm dziwne..., a wklej kod, który masz przed tym warunkiem, jeśli możesz ;p.
P-7924
Myslivius
Temat założony przez niniejszego użytkownika
» 2009-06-22 21:49:19
Moge wkleić i cały, może ktoś sobie skorzysta, jest to map editor do gry, której jeszcze nie ma xD
Niech ktoś może sproboje to skompilować z tym If'em i bez tego IF'a, to zobaczy o co chodzi.
Jeśli ktoś widzi jakieś błędy inne, to może odrazu mowić.

C/C++
#include <allegro.h>
#include <string>
#include <iostream>
#include <fstream>
#include <conio.h>
#include <io.h>
#include <list>

//struktura pól mapy
struct POLE
{
    short int numer_pliku;
    short int warstwa;
    bool kolizja;
};
struct LISTA_BMP
{
    std::string nazwa;
    short int numer;
    short int polozenie;
    short int wysokosc;
    short int szerokosc;
};
//funkcje
bool kolizja( float x1, float y1, float s1, float w1, float x2, float y2, float s2, float w2 )
{
    if( x1 + s1 >= x2 && x1 <= x2 + s2 && y1 + w1 >= y2 && y1 <= y2 + w2 ) return( true );
   
    return( false );
}

std::string wczyt( BITMAP * bufor, int y, int x )
{
    std::string napis;
    char znak = 0;
    while( 1 != 2 )
    {
        znak = readkey();
        if( znak == 13 ) break;
       
        napis += znak;
        if( znak == 8 ) { std::string napis1( napis, 0,( napis.length() - 2 ) ); napis = napis1;
            rectfill( bufor, x, y, x +(( napis.length() + 1 ) * 8 ), y + 10, getpixel( bufor, x - 1, y - 1 ) ); }
        textprintf_ex( bufor, font, x, y, makecol( 200, 200, 200 ), - 1, "% s ", napis.c_str() );
        blit( bufor, screen, 0, 0, 0, 0, 640, 480 ); //kopiowanie zawartości bufora na ekran
    }
    return napis;
}

void rysuj_siatke( BITMAP * bufor )
{
    for( int q = 0; q <= 465; q += 31 ) vline( bufor, q + 5, 5, 470, makecol( 255, 255, 255 ) );
   
    for( int w = 0; w <= 465; w += 31 ) hline( bufor, 5, w + 5, 470, makecol( 255, 255, 255 ) );
   
}

std::list < std::string > znajdz_pliki( std::list < std::string > lista_plikow )
{
    long uchwyt;
    _finddata_t danePliku;
    if(( uchwyt = _findfirst( "*.bmp", & danePliku ) ) != - 1 )
    {
        lista_plikow.clear();
        do
        {
            lista_plikow.push_back( danePliku.name );
        }
        while( !_findnext( uchwyt, & danePliku ) );
       
    }
    return lista_plikow;
}

//****************************************FUNKCJA MAIN***************************************


int main()
{
    allegro_init();
    install_keyboard();
    install_mouse();
    set_color_depth( 16 );
    set_gfx_mode( GFX_AUTODETECT_FULLSCREEN, 640, 480, 0, 0 );
    //zmienne i wskaźniki na bitmapy
    enum STAN_MENU { M_NOWA_MAPA = 1, M_WCZYTAJ_MAPE = 2, M_WYJDZ = 3, M_WYBOR = 0, M_EDYCJA = 4 };
    enum STAN_PROGRAMU { S_MENU, S_EDYTOR };
    BITMAP * bufor = create_bitmap( 640, 480 );
    BITMAP * pliki = NULL;
    BITMAP * bitmap = NULL;
    BITMAP * uzyte_bitmapy = NULL;
    BITMAP * bitmapy = NULL;
    BITMAP * bitmapy_lista = NULL;
    BITMAP * wybrany = NULL;
    bitmapy_lista = create_bitmap( 150, 290 );
    clear_to_color( bitmapy_lista, makecol( 0, 0, 200 ) );
    STAN_PROGRAMU stan_programu = S_MENU;
    STAN_MENU stan_menu = M_WYBOR;
    std::string nazwa_mapy;
    std::list < std::string > lista_plikow;
    std::list < std::string >::iterator L;
    std::string nazwa_pojedynczego_pliku;
    int licznik_y_plikow;
    bool lista_pobrana = false;
    bool nowa_bitmapa = false;
    bool odswiez = true;
    int pos_y_b = 0;
    int pos_y = 0;
    int aktualna_bitmapa =- 1;
    short int ilosc_bmp;
    int licznik_pos_y = 0;
    int licznik_pos_y_b = 200;
    std::string aktualny_plik_bmp;
    std::string poprzedni_plik_bmp;
    int dlugosc_bitmapy_pliki = 100;
    int dlugosc_bitmapy_bitmapy_lista = 290;
    int licznik_przejscia_L = 0;
    int dlugosc_suwaka_gornego;
    int dlugosc_suwaka_dolnego;
    int dlugosc_bitmapy_uzytych_bmp = 0;
    int szerokosc_bitmapy_uzytych_bmp = 0;
    int liczba_plikow_na_liscie = 0;
    short int aktualny_numer_pliku_bmp = 0;
    bool tryb = false;
    bool czy_jest_plik = false;
    bool czy_dodano_do_listy = false;
    int mapa_y = 0;
    int mapa_x = 0;
    POLE mapa[ 500 ][ 500 ];
    for( int i = 0; i < 500; ++i )
    for( int g = 0; g < 500; ++g )
    { mapa[ i ][ g ].warstwa =- 1;
        mapa[ i ][ g ].numer_pliku =- 1;
        mapa[ i ][ g ].kolizja = false; }
    std::list < BITMAP *> lista_bitmap_w_pliku;
    LISTA_BMP lista_uzytych_plikow_bmp[ 100 ];
    std::list < BITMAP *>::iterator B;
    std::string txt;
    //rozpoczęcie pętli główej   
    while( stan_menu != M_WYJDZ && !key[ KEY_ESC ] )
    {
        //obsługa menu
        if( stan_programu == S_MENU )
        {
            rectfill( bufor, 230, 120, 420, 160, makecol( 128, 30, 30 ) );
            rectfill( bufor, 230, 180, 420, 220, makecol( 128, 30, 30 ) );
            rectfill( bufor, 230, 240, 420, 280, makecol( 128, 30, 30 ) );
            textprintf_ex( bufor, font, 290, 140, makecol( 200, 200, 200 ), - 1, "NOWA MAPA" );
            textprintf_ex( bufor, font, 280, 200, makecol( 200, 200, 200 ), - 1, "WCZYTAJ MAPE" );
            textprintf_ex( bufor, font, 305, 260, makecol( 200, 200, 200 ), - 1, "WYJDZ" );
            if( kolizja( 230, 120, 190, 40, mouse_x, mouse_y, 1, 1 ) ) floodfill( bufor, 231, 121, makecol( 20, 120, 20 ) );
           
            if( kolizja( 230, 180, 190, 40, mouse_x, mouse_y, 1, 1 ) ) floodfill( bufor, 231, 181, makecol( 20, 120, 20 ) );
           
            if( kolizja( 230, 240, 190, 40, mouse_x, mouse_y, 1, 1 ) ) floodfill( bufor, 231, 241, makecol( 20, 120, 20 ) );
           
            if( kolizja( 230, 120, 190, 40, mouse_x, mouse_y, 1, 1 ) && mouse_b == 1 ) { stan_programu = S_EDYTOR; stan_menu = M_NOWA_MAPA; }
            if( kolizja( 230, 180, 190, 40, mouse_x, mouse_y, 1, 1 ) && mouse_b == 1 ) { stan_programu = S_EDYTOR; stan_menu = M_WCZYTAJ_MAPE; }
            if( kolizja( 230, 240, 190, 40, mouse_x, mouse_y, 1, 1 ) && mouse_b == 1 ) { stan_programu = S_EDYTOR; stan_menu = M_WYJDZ; }
        }
       
        //edytor
        if( stan_programu == S_EDYTOR )
        {
            if( stan_menu == M_NOWA_MAPA || stan_menu == M_WCZYTAJ_MAPE )
            {
                clear_to_color( bufor, makecol( 100, 100, 100 ) ); //czyszczenie ekranu                  
                rectfill( bufor, 90, 220, 560, 240, makecol( 128, 30, 30 ) );
                textprintf_ex( bufor, font, 100, 225, makecol( 200, 200, 200 ), - 1, "Podaj nazwe mapy i nacisnij ENTER" );
                blit( bufor, screen, 0, 0, 0, 0, 640, 480 ); //kopiowanie zawartości bufora na ekran
                clear_to_color( bufor, makecol( 100, 100, 100 ) ); //czyszczenie ekranu
                rectfill( bufor, 90, 220, 560, 240, makecol( 128, 30, 30 ) );
                nazwa_mapy =( wczyt( bufor, 225, 260 ) += ".txt" );
                //**********************************WCZYTYWANIE PLIKU******************************
                if( stan_menu == M_WCZYTAJ_MAPE )
                {
                    std::fstream plik( nazwa_mapy.c_str(), std::ios::in );
                    plik >> txt;
                    //INTERPRETACJA PLIKU (bufora "txt")
                    char bufor_m;
                    int licznik_m = 0;
                    int licznik_c = 0;
                    int licznik_l = 0;
                    std::string mapa_s[ 500 ][ 500 ];
                    //wczytywanie do listy plików nazw i numerów plików
                    do
                    {
                        do
                        {
                            bufor_m = txt[ licznik_c ];
                            ++licznik_c;
                            if( bufor_m == ',' ) break;
                           
                            lista_uzytych_plikow_bmp[ licznik_l ].nazwa += bufor_m;
                            lista_uzytych_plikow_bmp[ licznik_l ].numer = licznik_l;
                        } while( 1 != 2 );
                       
                        ++licznik_l;
                    } while( txt[ licznik_c ] != '|' );
                    //czyszczenie mapy_s
                    for( int v = 0; v < 500; ++v )
                    for( int b = 0; b < 500; ++b )
                         mapa_s[ v ][ b ] = "";
                    //wczytywanie do mapy numerów plików
                    do
                    {
                        for( int v = 0; v < 500; ++v )
                        for( int b = 0; b < 500; ++b )
                        {
                            do
                            {
                                bufor_m = txt[ licznik_c ];
                                ++licznik_c;
                                if( bufor_m == ',' ) break;
                               
                                mapa_s[ v ][ b ] += bufor_m;
                            } while( 1 != 2 );
                           
                        }
                        for( int v = 0; v < 500; ++v )
                        for( int b = 0; b < 500; ++b )
                        {
                            mapa[ v ][ b ].numer_pliku = atoi( mapa_s[ v ][ b ].c_str() );
                        }
                    } while( txt[ licznik_c ] != '|' );
                    //czyszczenie mapy_s
                    for( int v = 0; v < 500; ++v )
                    for( int b = 0; b < 500; ++b )
                         mapa_s[ v ][ b ] = "";
                    //wczytywanie do mapy kolizji
                    do
                    {
                        for( int v = 0; v < 500; ++v )
                        for( int b = 0; b < 500; ++b )
                        {
                            do
                            {
                                bufor_m = txt[ licznik_c ];
                                ++licznik_c;
                                if( bufor_m == ',' ) break;
                               
                                mapa_s[ v ][ b ] += bufor_m;
                            } while( 1 != 2 );
                           
                        }
                        for( int v = 0; v < 500; ++v )
                        for( int b = 0; b < 500; ++b )
                        {
                            mapa[ v ][ b ].kolizja = atoi( mapa_s[ v ][ b ].c_str() );
                        }
                    } while( txt[ licznik_c ] != '|' );
                    //czyszczenie mapy_s
                    for( int v = 0; v < 500; ++v )
                    for( int b = 0; b < 500; ++b )
                         mapa_s[ v ][ b ] = "";
                    //wczytywanie do mapy numerów bitmap (".warstwa")
                    do
                    {
                        for( int v = 0; v < 500; ++v )
                        for( int b = 0; b < 500; ++b )
                        {
                            do
                            {
                                bufor_m = txt[ licznik_c ];
                                ++licznik_c;
                                if( bufor_m == ',' ) break;
                               
                                mapa_s[ v ][ b ] += bufor_m;
                            } while( 1 != 2 );
                           
                        }
                        for( int v = 0; v < 500; ++v )
                        for( int b = 0; b < 500; ++b )
                        {
                            mapa[ v ][ b ].warstwa = atoi( mapa_s[ v ][ b ].c_str() );
                        }
                    } while( txt[ licznik_c ] != '|' );
                   
                }
                stan_menu = M_EDYCJA;
            }
            if( stan_menu == M_EDYCJA )
            {
                //rysowanie siatki                 
                rysuj_siatke( bufor );
                //ładowanie bitmap z plikow na bitmapę główną
                if( czy_dodano_do_listy == true )
                {
                    czy_dodano_do_listy = false;
                    dlugosc_bitmapy_uzytych_bmp = 0;
                    for( int G = 0; G < 100; ++G )
                    {
                        if( lista_uzytych_plikow_bmp[ G ].nazwa != "" )
                        {
                            bitmap = load_bitmap( lista_uzytych_plikow_bmp[ G ].nazwa.c_str(), default_palette );
                            lista_uzytych_plikow_bmp[ G ].polozenie = dlugosc_bitmapy_uzytych_bmp;
                            lista_uzytych_plikow_bmp[ G ].wysokosc = bitmap->h;
                            lista_uzytych_plikow_bmp[ G ].szerokosc = bitmap->w;
                            dlugosc_bitmapy_uzytych_bmp += bitmap->h;
                            if( bitmap->w > szerokosc_bitmapy_uzytych_bmp ) szerokosc_bitmapy_uzytych_bmp = bitmap->w;
                           
                        }
                    }
                    uzyte_bitmapy = NULL;
                    uzyte_bitmapy = create_bitmap( szerokosc_bitmapy_uzytych_bmp, dlugosc_bitmapy_uzytych_bmp );
                    for( int G = 0; G < 100; ++G )
                    {
                        if( lista_uzytych_plikow_bmp[ G ].nazwa != "" )
                        {
                            bitmap = load_bitmap( lista_uzytych_plikow_bmp[ G ].nazwa.c_str(), default_palette );
                            blit( bitmap, uzyte_bitmapy, 0, 0, 0, lista_uzytych_plikow_bmp[ G ].polozenie, bitmap->w, bitmap->h );
                        }
                    }
                }
                //wyświetlenie mapy
                if( tryb == false )
                {
                    short int stary_numer =- 1;
                    short int nowy_numer =- 1;
                    int numerek =- 1;
                    int licznik_y, licznik_x, licznik_w = 0;
                    for( licznik_x = 0; licznik_x < 15; ++licznik_x )
                    for( licznik_y = 0; licznik_y < 15; ++licznik_y )
                    {
                        nowy_numer = mapa[ licznik_y + mapa_y / 31 ][ licznik_x + mapa_x / 31 ].numer_pliku;
                        if( nowy_numer != stary_numer && nowy_numer !=- 1 )
                        {
                            for( int G = 0; G < 100; ++G )
                            {
                                if( lista_uzytych_plikow_bmp[ G ].numer == nowy_numer ) numerek = lista_uzytych_plikow_bmp[ G ].numer;
                               
                            }
                            stary_numer = nowy_numer;
                        }
                        if( nowy_numer !=- 1 && mapa[ licznik_y + mapa_y / 31 ][ licznik_x + mapa_x / 31 ].warstwa !=- 1 && numerek !=- 1 )
                        masked_blit( uzyte_bitmapy, bufor,
                        (( mapa[ licznik_y + mapa_y / 31 ][ licznik_x + mapa_x / 31 ].warstwa %( lista_uzytych_plikow_bmp[ numerek ].szerokosc / 30 ) ) * 30 ),
                        (( mapa[ licznik_y + mapa_y / 31 ][ licznik_x + mapa_x / 31 ].warstwa /( lista_uzytych_plikow_bmp[ numerek ].szerokosc / 30 ) ) * 30 ) + lista_uzytych_plikow_bmp[ numerek ].polozenie,
                             licznik_x * 31 + 6, licznik_y * 31 + 6, 30, 30 );
                       
                    }
                    //edytowanie mapy
                    for( int g = 0; g < 15; ++g )
                    for( int i = 0; i < 15; ++i )
                    {
                        if( kolizja( 6 +( i * 31 ), 6 +( g * 31 ), 30, 30, mouse_x, mouse_y, 1, 1 ) && mouse_b == 1 )
                        if( mouse_y < 470 && mouse_y > 6 && mouse_x < 470 && mouse_x > 6 )
                        {
                            mapa[ g ][ i +( mapa_x / 31 ) ].warstwa = aktualna_bitmapa;
                            mapa[ g +( mapa_y / 31 ) ][ i +( mapa_x / 31 ) ].numer_pliku = aktualny_numer_pliku_bmp;
                            czy_jest_plik = false;
                            for( int G = 0; G < 100; ++G )
                            {
                                if( lista_uzytych_plikow_bmp[ G ].nazwa == aktualny_plik_bmp ) { czy_jest_plik = true; aktualny_numer_pliku_bmp = lista_uzytych_plikow_bmp[ G ].numer; }
                            }
                            if( czy_jest_plik == false ) { aktualny_numer_pliku_bmp = liczba_plikow_na_liscie; lista_uzytych_plikow_bmp[ liczba_plikow_na_liscie ].numer = aktualny_numer_pliku_bmp; lista_uzytych_plikow_bmp[ liczba_plikow_na_liscie ].nazwa = aktualny_plik_bmp; czy_dodano_do_listy = true; ++liczba_plikow_na_liscie; }
                        }
                    }
                }
                else
                {
                    int licznik_y, licznik_x, licznik_w = 0;
                    for( licznik_x = 0; licznik_x < 15; ++licznik_x )
                    for( licznik_y = 0; licznik_y < 15; ++licznik_y )
                    {
                        if( mapa[ licznik_y + mapa_y / 31 ][ licznik_x + mapa_x / 31 ].kolizja == true ) floodfill( bufor, licznik_x * 31 + 21, licznik_y * 31 + 21, makecol( 20, 120, 20 ) );
                       
                    }
                    //edytowanie mapy
                    for( int g = 0; g < 15; ++g )
                    for( int i = 0; i < 15; ++i )
                    {
                        if( kolizja( 6 +( i * 31 ), 6 +( g * 31 ), 30, 30, mouse_x, mouse_y, 1, 1 ) && mouse_b == 1 ) if( mouse_y < 470 && mouse_y > 6 && mouse_x < 470 && mouse_x > 6 ) mapa[ g +( mapa_y / 31 ) ][ i +( mapa_x / 31 ) ].kolizja = true;
                       
                        if( kolizja( 6 +( i * 31 ), 6 +( g * 31 ), 30, 30, mouse_x, mouse_y, 1, 1 ) && mouse_b == 2 ) if( mouse_y < 470 && mouse_y > 6 && mouse_x < 470 && mouse_x > 6 ) mapa[ g +( mapa_y / 31 ) ][ i +( mapa_x / 31 ) ].kolizja = false;
                       
                    }
                }
               
                // SCROLLOWANIE MAPY
                if(( key[ KEY_LEFT ] ) &&( mapa_x >= 31 ) ) { mapa_x -= 31; rest( 80 ); } else
                if(( key[ KEY_RIGHT ] ) &&( mapa_x < 15500 ) ) { mapa_x += 31; rest( 80 ); } else
                if(( key[ KEY_DOWN ] ) &&( mapa_y < 15500 ) ) { mapa_y += 31; rest( 80 ); } else
                if(( key[ KEY_UP ] ) &&( mapa_y >= 31 ) ) { mapa_y -= 31; rest( 80 ); }
                //pobranie listy plików {na początku i jeżeli ktoś odświeży}
                if( lista_pobrana == false )
                {
                    lista_plikow = znajdz_pliki( lista_plikow );
                    licznik_przejscia_L = 0;
                    licznik_y_plikow = 0;
                    dlugosc_bitmapy_pliki = 100;
                    for( L = lista_plikow.begin(); L != lista_plikow.end(); ++L )
                    {
                        if( licznik_przejscia_L > 8 ) dlugosc_bitmapy_pliki += 10;
                       
                        ++licznik_przejscia_L;
                    }
                    pliki = NULL;
                    pliki = create_bitmap( 150, dlugosc_bitmapy_pliki );
                    clear_to_color( pliki, makecol( 0, 0, 200 ) ); //czyszczenie bitmapy z listą plików
                    for( L = lista_plikow.begin(); L != lista_plikow.end(); ++L )
                    {
                        licznik_y_plikow += 10;
                        nazwa_pojedynczego_pliku =* L;
                        textprintf_ex( pliki, font, 5, licznik_y_plikow, makecol( 200, 200, 200 ), - 1, "% s ", nazwa_pojedynczego_pliku.c_str() );
                    }
                    lista_pobrana = true;
                }
                //*******************funkcja całego paska górnego po prawej*************************
                //wklejenie odpowiedniej części bitmapy z listą plików na ekran
                blit( pliki, bufor, 0, pos_y, 480, 10, 150, 100 );
                //rysowanie przycisku "ZAPISZ"
                rectfill( bufor, 570, 135, 630, 160, makecol( 200, 200, 0 ) );
                textprintf_ex( bufor, font, 577, 145, makecol( 0, 0, 0 ), - 1, "ZAPISZ" );
                //rysowanie kropki wyboru trybu {kolizja}
                rectfill( bufor, 480, 135, 490, 145, makecol( 200, 200, 0 ) );
                textprintf_ex( bufor, font, 495, 137, makecol( 0, 0, 0 ), - 1, "kolizijny" );
                //rysowanie kropki wyboru trybu {normalny}
                rectfill( bufor, 480, 150, 490, 160, makecol( 200, 200, 0 ) );
                textprintf_ex( bufor, font, 495, 152, makecol( 0, 0, 0 ), - 1, "normalny" );
                //rysowanie kropki wybranego trybu {normalny/kolizja}
                if( tryb == false ) rectfill( bufor, 482, 152, 488, 158, makecol( 200, 0, 0 ) );
                else rectfill( bufor, 482, 137, 488, 143, makecol( 200, 0, 0 ) );
                //rysowanie suwaka od pola z listą plików
                dlugosc_suwaka_gornego = static_cast < int >( 60.0 *( 100.0 / static_cast < float >( pliki->h ) ) );
                rectfill( bufor, 610, static_cast < int >( 60.0 / static_cast < float >( pliki->h ) * 100.0 ) * pos_y / 100 + 31, 629, static_cast < int >( 60.0 / static_cast < float >( pliki->h ) * 100.0 ) * pos_y / 100 + 31 + dlugosc_suwaka_gornego, makecol( 200, 0, 0 ) );
                //rysowanie strzałki górnej od pola z listą plików
                rectfill( bufor, 610, 10, 629, 30, makecol( 500, 200, 0 ) );
                triangle( bufor, 620, 15, 615, 25, 625, 25, makecol( 255, 0, 128 ) );
                //rysowanie strzałki dolnej od pola z listą plików
                rectfill( bufor, 610, 90, 629, 109, makecol( 500, 200, 0 ) );
                triangle( bufor, 620, 105, 615, 95, 625, 95, makecol( 255, 0, 128 ) );
                //rysowanie paska do odświeżania listy plików
                rectfill( bufor, 480, 110, 630, 130, makecol( 500, 0, 0 ) );
                textprintf_ex( bufor, font, 500, 116, makecol( 200, 200, 200 ), - 1, "ODSWIEZ LISTE" );
                //sprawdzenie kolizji kropki wyboru trybu {kolizja}
                if( kolizja( 480, 135, 10, 10, mouse_x, mouse_y, 1, 1 ) && mouse_b == 1 ) tryb = true;
                //sprawdzenie kolizji kropki wyboru trybu {normalny}
                if( kolizja( 480, 150, 10, 10, mouse_x, mouse_y, 1, 1 ) && mouse_b == 1 ) tryb = false;
                //sprawdzenie kolizji paska odświerz
                if( kolizja( 480, 110, 150, 20, mouse_x, mouse_y, 1, 1 ) && mouse_b == 1 ) { lista_pobrana = false; rectfill( bufor, 480, 110, 630, 130, makecol( 200, 200, 200 ) ); textprintf_ex( bufor, font, 500, 116, makecol( 0, 200, 0 ), - 1, "ODSWIEZ LISTE" ); }
                //sprawdzenie kolizji strzałki w górę
                if( kolizja( 610, 10, 30, 30, mouse_x, mouse_y, 1, 1 ) && mouse_b == 1 ) { --pos_y; rectfill( bufor, 610, 10, 629, 30, makecol( 200, 200, 200 ) ); triangle( bufor, 620, 15, 615, 25, 625, 25, makecol( 0, 200, 0 ) ); }
                //sprawdzenie kolizji strzałki w dół
                if( kolizja( 610, 90, 30, 30, mouse_x, mouse_y, 1, 1 ) && mouse_b == 1 ) { ++pos_y; rectfill( bufor, 610, 90, 629, 109, makecol( 200, 200, 200 ) ); triangle( bufor, 620, 105, 615, 95, 625, 95, makecol( 0, 200, 0 ) ); }
                //ograniczenia przesuwania listy plików
                if( pos_y < 0 ) pos_y = 0;
               
                if( pos_y >( dlugosc_bitmapy_pliki - 100 ) ) pos_y =( dlugosc_bitmapy_pliki - 100 );
                //kolizje z poszczególnymi plikami na liście plików
                licznik_pos_y = 20;
                for( L = lista_plikow.begin(); L != lista_plikow.end(); ++L )
                {
                    if( kolizja( 480, licznik_pos_y - pos_y, 130, 10, mouse_x, mouse_y, 1, 1 ) && mouse_b == 1 ) if( mouse_y > 10 && mouse_y < 110 ) aktualny_plik_bmp =* L;
                   
                    licznik_pos_y += 10;
                }
                //sprawdzanie kolizji przycisku "ZAPISZ"
                if( kolizja( 570, 135, 60, 25, mouse_x, mouse_y, 1, 1 ) && mouse_b == 1 )
                {
                    rectfill( bufor, 570, 135, 630, 160, makecol( 200, 200, 200 ) );
                    textprintf_ex( bufor, font, 577, 145, makecol( 0, 200, 0 ), - 1, "ZAPISZ" );
                    //zapisywanie mapy do pliku
                    std::fstream plik( nazwa_mapy.c_str(), std::ios::out );
                    txt = "";
                    for( int G = 0; G < 100; ++G )
                    {
                        if( lista_uzytych_plikow_bmp[ G ].nazwa != "" )
                        {
                            txt += lista_uzytych_plikow_bmp[ G ].nazwa;
                            txt += ',';
                        }
                    }
                    txt += "|";
                    char str[ 3 ];
                    for( int a = 0; a < 500; ++a )
                    for( int s = 0; s < 500; ++s )
                    {
                        itoa( mapa[ a ][ s ].numer_pliku, str, 10 );
                        txt += str;
                        txt += ',';
                    }
                    txt += "|";
                    for( int a = 0; a < 500; ++a )
                    for( int s = 0; s < 500; ++s )
                    {
                        if( mapa[ a ][ s ].kolizja == 0 ) txt += '0';
                        else txt += '1';
                       
                        txt += ',';
                    }
                    txt += "|";
                    for( int a = 0; a < 500; ++a )
                    for( int s = 0; s < 500; ++s )
                    {
                        itoa( mapa[ a ][ s ].warstwa, str, 10 );
                        txt += str;
                        txt += ',';
                    }
                    txt += "|";
                   
                    plik.write( & txt[ 0 ], txt.length() ); //zapisuje dane poczynając od 0 indeksu
                    txt = "";
                }
                //*******************funkcja całego paska dolnego po prawej*************************
                //wyświetlanie nazwy aktualnie wybranego pliku
                rectfill( bufor, 480, 164, 629, 184, makecol( 0, 200, 0 ) );
                textprintf_ex( bufor, font, 485, 171, makecol( 0, 0, 0 ), - 1, "% s ", aktualny_plik_bmp.c_str() );
                //wczytywanie obrazków z poszczególnych plików
                if( aktualny_plik_bmp != "" && aktualny_plik_bmp != poprzedni_plik_bmp )
                {
                    bitmapy = load_bmp( aktualny_plik_bmp.c_str(), default_palette );
                    ilosc_bmp =(( bitmapy->w / 30 ) *( bitmapy->h / 30 ) );
                    dlugosc_bitmapy_bitmapy_lista = 290;
                    if( ilosc_bmp / 3 > 7 ) dlugosc_bitmapy_bitmapy_lista +=( 35 *( ilosc_bmp / 3 - 7 ) + 15 );
                   
                    bitmapy_lista = NULL;
                    bitmapy_lista = create_bitmap( 150, dlugosc_bitmapy_bitmapy_lista );
                    clear_to_color( bitmapy_lista, makecol( 0, 0, 200 ) );
                    for( int i = 0; i != ilosc_bmp; ++i )
                    {
                        blit( bitmapy, bitmapy_lista,( i %( bitmapy->w / 30 ) ) * 30,( i /( bitmapy->w / 30 ) ) * 30, 15 +(( i % 3 ) * 35 ), 15 +(( i / 3 ) * 35 ), 30, 30 );
                    }
                    poprzedni_plik_bmp = aktualny_plik_bmp;
                    nowa_bitmapa = true;
                    bitmapy = NULL;
                }
                //wklejenie odpowiedniej części bitmapy z listą bitmap na ekran
                blit( bitmapy_lista, bufor, 0, pos_y_b, 480, 185, 150, 290 );
                //rysowanie suwaka od pola z listą plików
                dlugosc_suwaka_dolnego = static_cast < int >( 250.0 *( 290.0 / static_cast < float >( bitmapy_lista->h ) ) );
                rectfill( bufor, 610, static_cast < int >( 250.0 / static_cast < float >( bitmapy_lista->h ) * 100.0 ) * pos_y_b / 100 + 206, 629, static_cast < int >( 250.0 / static_cast < float >( bitmapy_lista->h ) * 100.0 ) * pos_y_b / 100 + 206 + dlugosc_suwaka_dolnego, makecol( 200, 0, 0 ) );
                //rysowanie strzałki górnej od pola z listą plików
                rectfill( bufor, 610, 185, 629, 205, makecol( 500, 200, 0 ) );
                triangle( bufor, 620, 190, 615, 200, 625, 200, makecol( 255, 0, 128 ) );
                //rysowanie strzałki dolnej od pola z listą plików
                rectfill( bufor, 610, 455, 629, 474, makecol( 500, 200, 0 ) );
                triangle( bufor, 620, 470, 615, 460, 625, 460, makecol( 255, 0, 128 ) );
                //sprawdzenie kolizji strzałki w górę
                if( kolizja( 610, 185, 30, 30, mouse_x, mouse_y, 1, 1 ) && mouse_b == 1 ) { --pos_y_b; rectfill( bufor, 610, 185, 629, 205, makecol( 200, 200, 200 ) ); triangle( bufor, 620, 190, 615, 200, 625, 200, makecol( 0, 200, 0 ) ); }
                //sprawdzenie kolizji strzałki w dół
                if( kolizja( 610, 455, 30, 30, mouse_x, mouse_y, 1, 1 ) && mouse_b == 1 ) { ++pos_y_b; rectfill( bufor, 610, 455, 629, 474, makecol( 200, 200, 200 ) ); triangle( bufor, 620, 470, 615, 460, 625, 460, makecol( 0, 200, 0 ) ); }
                //ograniczenia przesuwania listy plików
                if( pos_y_b < 0 ) pos_y_b = 0;
               
                if( pos_y_b > dlugosc_bitmapy_bitmapy_lista - 290 ) pos_y_b = dlugosc_bitmapy_bitmapy_lista - 290;
                //kolizje z poszczególnymi bitmapami na liście bitmap
                for( int g = 0; g != 3; ++g )
                {
                    for( int i = 0; i != ilosc_bmp / 3 + 1; ++i )
                    {
                        if( kolizja( 495 +( g * 35 ), 200 - pos_y_b + i * 35, 30, 30, mouse_x, mouse_y, 1, 1 ) && mouse_b == 1 ) if( i * 3 + g < ilosc_bmp && mouse_y > 185 && mouse_y < 475 ) aktualna_bitmapa = i * 3 + g;
                       
                    }
                }
            }
           
        }
        //podstawienie bitmapy terenu pod myszkę
        if( mouse_b == 2 ) aktualna_bitmapa =- 1;
       
        if( aktualny_plik_bmp != "" && aktualna_bitmapa !=- 1 && aktualna_bitmapa !=- 2 && nowa_bitmapa == true )
        {
            wybrany = load_bmp( aktualny_plik_bmp.c_str(), default_palette );
            nowa_bitmapa = false;
        }
        if( aktualny_plik_bmp != "" && aktualna_bitmapa !=- 1 )
        {
            masked_blit( wybrany, bufor,( aktualna_bitmapa %( wybrany->w / 30 ) ) * 30,( aktualna_bitmapa /( wybrany->w / 30 ) ) * 30, mouse_x - 15, mouse_y - 15, 30, 30 );
        }
        //rysowanie myszki   
        rectfill( bufor, mouse_x + 3, mouse_y + 3, mouse_x - 3, mouse_y - 3, makecol( 0, 0, 300 ) );
        rectfill( bufor, mouse_x + 2, mouse_y + 2, mouse_x - 2, mouse_y - 2, makecol( 200, 200, 1 ) );
        //kopiowanie zawartości bufora na ekran
        blit( bufor, screen, 0, 0, 0, 0, 640, 480 );
        //czyszczenie ekranu
        clear_to_color( bufor, makecol( 100, 100, 100 ) );
       
    }
    destroy_bitmap( uzyte_bitmapy );
    destroy_bitmap( wybrany );
    destroy_bitmap( bitmapy_lista );
    destroy_bitmap( bitmapy );
    destroy_bitmap( bitmap );
    destroy_bitmap( bufor );
    destroy_bitmap( pliki );
    allegro_exit();
    return 0;
}
END_OF_MAIN();




EDIT
Wiem juz co powoduje błąd:
C/C++
std::string mapa_s[ 500 ][ 500 ];
Wystarczy, że zmniejszę liczbę pól mapy np. na [1][1]i po problemie, tyle że wtedy reszta kodu bedzie bez sensu.
Może mi ktoś powiedzieć, czemu to powoduje błąd i czy można coś na to poradzić? A może to przez kompilator-używam Dev C**.

Zresztą jak teraz pomyśle, to miłem ten problem wcześniej, gdy próbowałem zwykłą mapę zadeklarować z liczbą pól np.[1000][1000]
Czyżby brakowało pamięci?



EDIT 2
Poprawiłem już funkcję wczytującą, usuwając tą zmienną i zastępując ją zwykłym
std::string mapa_s;
Przebudowałem resztę, co ogromnie przyspieszy fuynkcję, bo pozbyłem się kilku pętli i zaoszczędziłem pamięć ;), ale moje pytanie czemu tamto powodowało błąd jest nadal aktualne.
P-7927
« 1 » 2
  Strona 1 z 2 Następna strona
» Forum » Programowanie » [C, C++] Szukam pomocy
© Wszelkie prawa zastrzeżone 2005-2025