Dziwne zachowanie GM'a

[Danielus]

Nie dawno wróciłem do robienia swojego starszego ale już dosyć rozbudowanego projektu.

No i mam sobie niedokończony dll który miał służyć m. in. do szukania ścieżek na hexowych mapach.

 

Od razu trochę się jednak zdziwiłem( i naprawdę nie pamiętam czemu tak wcześniej zrobiłem )

Otóż mam taki kod w skrypcie inicjującym:

GML

global._Battledll_Init=external_define('Battledll.dll','Battle_Init',dll_cdecl,ty_real,2,ty_real,ty_string);

 

Natomias dll:

battle.h

export double Battle_Init( double, double);

battle.cpp

double Battle_Init( double wysokosc_mapy, double szerokosc_mapy )
{
       battle.battlefield.init((int)wysokosc_mapy,(int)szerokosc_mapy);
}

 

Jak widać oba argumenty są typu double, natomiast w game makerze drugi argument jest stringiem.

I wszystko jest ok gra uruchamia się bez błędów, dll też reaguje tylko że cały czas zwraca jakieś śmieci zamiast tego czego bym chciał i sądzę że to właśnie wina tego stringa.

 

Dodam jeszcze że gdy wpisze drugi typ jako ty_real to wyskakuje standardowo o niespodziewanym błędzie.

 

Nie rozumiem też czemu nic się nie dzieje jeśli game maker rzeczywiście przesyła stringa do doubla( żadnych błędów? )

[gnysek]

Przede wszystkim, to funkcja "double Battle_Init" powinna zwracać typ double, a nie zwraca nic. Kompilator nie sypie ostrzeżeniem albo błędem w tym miejscu?

[Danielus]

Nie, kompiluje się wszytko bez problemu.

Dodałem return 1 ale oczywiście nic się nie zmieniło.

 

Jeszcze co jest ciekawe to jeśli GM wysyła stringa to double z dll musi coś odebrac.

Ta funkcja init generuje dwuwymiarową tablicę dynamiczna( której drugi wymiar pochodzi od tego doubla ze stringiem ). Najlepsze jest to że odwołuje się w takim razie do nieistniejących indeksów które nie dość że nie istnieją to jeszcze zwracają jakieś wartości( bo prawda bezsensowne, ale błędu nie ma ).

[gnysek]

Jeśli po dodaniu return 1 i zmianie na ty_real nie pomogło, to nie wiem.

 

Zaglądając w kod 39dll znalazłem jednak coś takiego:

#define DLLEXPORT extern "C" __declspec(dllexport)

DLLEXPORT double nazwafunkcji() {}

 

Jak widzisz, poza export masz jeszcze "C" __declspec(dllexport)

[Danielus]

Już nie raz tworzyłem dlle i wszystkie działały( mam jeden szablon ich tworzenia ) więc tu raczej nie o to chodzi.

[gnysek]

Ciężko zgadywać, nie mając całego kodu.

[Konrad-GM]

GML

external_define('Battledll.dll','Battle_Init',dll_cdecl,ty_real,2,ty_real,ty_string);

export double Battle_Init( double, [b]double[/b]);

Coś argumenty porypałeś :)

[gnysek]

No własnie o tym mowa, ze jak da dwa razy ty_real, to GM sypie błędem.... czytać waść nie potrafisz?

[Danielus]

Próbowałem użyć dll w zupełnie nowym projekcie i dzieje się dokładnie to samo.

 

Z ty_string wywołuje się bez błędów z ty_real błąd( Najlepsze jest to że w nowym projekcie jest błąd GM'a a w tym starym teraz jest błąd Windowsowy( z wysyłanie raportu o błędach ))

 

 

Macie tu dlla, może z nim coś jest nie tak: KLIK

 

Jakieś pomysły?

[Danielus]

Zebrałem się w końcu i zacząłem dlla sprawdzać linijka po linijce i znalazłem błąd w pętli for( zwiększałem nie tą zmienną co trzeba )

Dziwny jednak jest ten brak reakcji przy wysyłaniu stringa do doubla.

 

W każdym razie mam teraz inny problemik z tym dllem:

Mam funkcje RANGE ( wszystko jest w dllu( DOWNLOAD ) wiec można ściągnąć i zobaczyć pełny kod )

 

void RANGE( int x_pos, int y_pos, int start_steps, int range )
      {
           int steps=start_steps;//liczba krokow ktora juz zostala zrobiona
           if( steps<range ) //kontynuujemy tylko jesli jestesmy w zasiegu
           {
           steps++; //zwiekszamy ilosc krokow ktore zrobilismy   
           if( pole_exists(x_pos-1,y_pos+1) )
           {
               if( x[x_pos-1].y[y_pos+1].free==FLAG_FREE ) //lewy dolny
               {
                   if( x[x_pos-1].y[y_pos+1].in_range==FLAG_OUT_OF_RANGE )
                   {
                       x[x_pos-1].y[y_pos+1].in_range=FLAG_IN_RANGE;
                       x[x_pos-1].y[y_pos+1].steps_number=steps;
                       x[x_pos-1].y[y_pos+1].x_previous=x_pos;
                       x[x_pos-1].y[y_pos+1].y_previous=y_pos;
                       RANGE(x_pos-1,y_pos+1,steps,range);
                   }
                   else
                   {
                       if( x[x_pos-1].y[y_pos+1].steps_number>steps ) //jezeli dotychczasowa liczba krokow byla wieksza to zamieniamy na krotsza sciezke
                       {
                           x[x_pos-1].y[y_pos+1].in_range=FLAG_IN_RANGE;
                           x[x_pos-1].y[y_pos+1].steps_number=steps;
                           x[x_pos-1].y[y_pos+1].x_previous=x_pos;
                           x[x_pos-1].y[y_pos+1].y_previous=y_pos;
                           RANGE(x_pos-1,y_pos+1,steps,range);
                       }
                   }
               }
           }
           if( pole_exists(x_pos-1,y_pos) ) //lewy
           {
               if( x[x_pos-1].y[y_pos].free==FLAG_FREE ) 
               {
                   if( x[x_pos-1].y[y_pos].in_range==FLAG_OUT_OF_RANGE )
                   {
                       x[x_pos-1].y[y_pos].in_range=FLAG_IN_RANGE;
                       x[x_pos-1].y[y_pos].steps_number=steps;
                       x[x_pos-1].y[y_pos].x_previous=x_pos;
                       x[x_pos-1].y[y_pos].y_previous=y_pos;
                       RANGE(x_pos-1,y_pos,steps,range);
                   }
                   else
                   {
                       if( x[x_pos-1].y[y_pos].steps_number>steps ) //jezeli dotychczasowa liczba krokow byla wieksza to zamieniamy na krotsza sciezke
                       {
                           x[x_pos-1].y[y_pos].in_range=FLAG_IN_RANGE;
                           x[x_pos-1].y[y_pos].steps_number=steps;
                           x[x_pos-1].y[y_pos].x_previous=x_pos;
                           x[x_pos-1].y[y_pos].y_previous=y_pos;
                           RANGE(x_pos-1,y_pos,steps,range);
                       }
                   }
               }
           }
           if( pole_exists(x_pos-1,y_pos-1) )
           {
               if( x[x_pos-1].y[y_pos-1].free==FLAG_FREE ) //lewy gorny
               {
                   if( x[x_pos-1].y[y_pos-1].in_range==FLAG_OUT_OF_RANGE )
                   {
                       x[x_pos-1].y[y_pos-1].in_range=FLAG_IN_RANGE;
                       x[x_pos-1].y[y_pos-1].steps_number=steps;
                       x[x_pos-1].y[y_pos-1].x_previous=x_pos;
                       x[x_pos-1].y[y_pos-1].y_previous=y_pos;
                       RANGE(x_pos-1,y_pos-1,steps,range);
                   }
                   else
                   {
                       if( x[x_pos-1].y[y_pos-1].steps_number>steps ) //jezeli dotychczasowa liczba krokow byla wieksza to zamieniamy na krotsza sciezke
                       {
                           x[x_pos-1].y[y_pos-1].in_range=FLAG_IN_RANGE;
                           x[x_pos-1].y[y_pos-1].steps_number=steps;
                           x[x_pos-1].y[y_pos-1].x_previous=x_pos;
                           x[x_pos-1].y[y_pos-1].y_previous=y_pos;
                           RANGE(x_pos-1,y_pos-1,steps,range);
                       }
                   }
               }
           }
           if( pole_exists(x_pos,y_pos-1) )
           {
               if( x[x_pos].y[y_pos-1].free==FLAG_FREE ) //prawy gorny
               {
                   if( x[x_pos].y[y_pos-1].in_range==FLAG_OUT_OF_RANGE )
                   {
                       x[x_pos].y[y_pos-1].in_range=FLAG_IN_RANGE;
                       x[x_pos].y[y_pos-1].steps_number=steps;
                       x[x_pos].y[y_pos-1].x_previous=x_pos;
                       x[x_pos].y[y_pos-1].y_previous=y_pos;
                       RANGE(x_pos,y_pos-1,steps,range);
                   }
                   else
                   {
                       if( x[x_pos].y[y_pos-1].steps_number>steps ) //jezeli dotychczasowa liczba krokow byla wieksza to zamieniamy na krotsza sciezke
                       {
                           x[x_pos].y[y_pos-1].in_range=FLAG_IN_RANGE;
                           x[x_pos].y[y_pos-1].steps_number=steps;
                           x[x_pos].y[y_pos-1].x_previous=x_pos;
                           x[x_pos].y[y_pos-1].y_previous=y_pos;
                           RANGE(x_pos,y_pos-1,steps,range);
                       }
                   }
               }
           }
           if( pole_exists(x_pos+1,y_pos) )
           {
               if( x[x_pos+1].y[y_pos].free==FLAG_FREE ) //prawy
               {
                   if( x[x_pos+1].y[y_pos].in_range==FLAG_OUT_OF_RANGE )
                   {
                       x[x_pos+1].y[y_pos].in_range=FLAG_IN_RANGE;
                       x[x_pos+1].y[y_pos].steps_number=steps;
                       x[x_pos+1].y[y_pos].x_previous=x_pos;
                       x[x_pos+1].y[y_pos].y_previous=y_pos;
                       RANGE(x_pos+1,y_pos,steps,range);
                   }
                   else
                   {
                       if( x[x_pos+1].y[y_pos].steps_number>steps ) //jezeli dotychczasowa liczba krokow byla wieksza to zamieniamy na krotsza sciezke
                       {
                           x[x_pos+1].y[y_pos].in_range=FLAG_IN_RANGE;
                           x[x_pos+1].y[y_pos].steps_number=steps;
                           x[x_pos+1].y[y_pos].x_previous=x_pos;
                           x[x_pos+1].y[y_pos].y_previous=y_pos;
                           RANGE(x_pos-1,y_pos,steps,range);
                       }
                   }
               }
           }

 

funkcja ta ma za określić zadanie które pola są w zasięgu i z którego pola sie na to trafiło( to potem wykorzystuje do szukania ścieżek, nie muszę szukać od nowa tylko przeskakuje z pola na pole ).

 

Niestety to nie działa - znakuje niewłaściwe pola, na dodatek gdy zwracam numer poprzedniego pola to potrafi nawet zwrócić wartości ujemne( co jest niemożliwe )

 

Funkcja ma teoretycznie dzialac tak: Mamy pole startowe i zasięg( np 2 pola ).

Wywołujemy range z tymi parametrami: RANGE( pole_x, pole_y, 0, zasięg )

0- zero dlatego ze dopiero zaczynamy i nie sprawdziliśmy jeszcze żadnego pola

Teraz wywołujemy funkcje RANGE dla wszystkich sasiadujaych pól( z tym że zamiast 0 w trzecim argumencie podajemy ile kroków już zrobiliśmy od pola startowego). i tak wywołujemy RANGE na każdym polu dopóki się nam nie skończy zasięg.

 

Wprawdzie to c++ ale nie chce zakładac osobnego tematu. Mam nadzieję że ktoś wie o co mi chodzi i jak to naprawic ^^

[Uzjel]

Nie bardzo wiem o co chodzi. Ale ten kawałek mnie niepokoi:

 

Dziwny jednak jest ten brak reakcji przy wysyłaniu stringa do doubla.

 

stringa do doubla ?

tak się nie da.

[Danielus]

To jest starszy problem i juz go rozwiazalem i owszem udalo się :)

Jeśli zmienna byla 2x ty_real to wywalało błąd bo próbowałem sie odniesc do niestniejacego elemtu tablicy( błąd w pentli for ) natomiast gdy dałem ty_string to wszystko działało tylko dll zwracał śmieci.