Tymon

A jednak.

GML text = 'Lorem ipsum dolor sit amet.'; for( i = 0; i < 10; i += 1 ) for( j = 0; j < 10; j += 1 ) chars[i,j] = ''; for( n = 1; n <= string_length( text ); n += 1 ) { do { i = round( random( 9 ) ); j = round( random( 9 ) ); } until( chars[i,j] == '' ) chars[i,j] = string_char_at( text, n ); } for( i = 0; i < 10; i+= 1 ) { for( j = 0; j < 10; j+= 1 ) { if( chars[i,j] == '' ) { chars[i,j] = chr( random_range( ord( 'A' ), ord( 'Z' ) ) ); } } }

To Ty chcesz kazać układać użytkownikowi ALFABET czy ZDANIE? GML for( i = 0; i < 10; i+= 1 ) for( j = 0; j < 10; j+= 1 ) chars[i,j] = chr( random_range( ord( 'A' ), ord( 'Z' ) ) );

GML text = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec iaculis egestas dui iaculis volutpat.'; for( i = 0; i < 10; i += 1 ) for( j = 0; j < 10; j += 1 ) chars[i,j] = ''; n = 0; while( n < string_length( text ) ) { i = round( random( 9 ) ); j = round( random( 9 ) ); if( chars[i,j] == '' ) { chars[i,j] = string_char_at( text, n + 1 ); n += 1; } }

Znaki w stringu indeksuje się od 1. Jeśli random_range jest od 0 do 23 to nie ma potrzeby dawać abs, to już będą dodatnie liczby. No i po co Ci mieszać coś co jest wymieszane? Nie ma potrzeby używania random kilka razy dla większej losowości.

To przecież są losowo. Chcesz wymieszać litery w zdaniu?

Wlosowywanie liter z tekstu do kolejnych komórek tablicy 10x10. GML text = 'Ala ma kota a kot ma ale!'; for( i = 0; i < 10; i+= 1 ) for( j = 0; j < 10; j+= 1 ) chars[i,j] = string_char_at( text, random_range( 1, string_length( text ) ) ); ?

1. collision_line nie collsion_line. 2. hspeed i vspeed równe jest 0 jeśli manipuluje się bezpośrednio na x i y. 3. Wystarczy wykorzystać domyślne zdarzenie kolizji do odjęcia HP, on już tam ma cały kod do tego. 4. Jeśli już tak dokładny jesteś: GML object = collision_line( xprevious, yprevious, x, y, wrog, true, true ); if( object ) { sx = xprevious; sy = yprevious; ex = x; ey = y; while( point_distance( sx, sy, ex, ey ) > 5 ) { cx = ( sx + ex ) / 2; cy = ( sy + ey ) / 2; collision = collision_line( sx, sy, cx, cy, wrog, true, true ); if( collision != noone ) { ex = cx; ey = cy; object = collision; } else { sx = cx; sy = cy; } } event_perform( ev_collision, object.object_index ); with( object ) { event_perform( ev_collision, other.object_index ); } }

karolo320, słyszałeś o do...while? :) Po za tym nie wiem co Ty w ogóle liczysz. Wystarczy sprawdzić kolizję po linii i wywołać domyślne zdarzenie kolizji, które już ma. GML collision = collision_line( xprevious, yprevious, x, y, wrog, true, true ); if( collision != noone ) { event_perform( ev_collision, collision.object_index ); with( collision ) { event_perform( ev_collision, other.object_index ); } }

Nie oktadecymalne tylko hexadecymalne. GML (dectohex) var _dec, _hex, _r; _dec = floor( argument0 ); _hex = ''; while( _dec != 0 ) { _r = _dec & 15; if( _r > 9 ) { _hex = chr( _r + 55 ) + _hex; } else { _hex += chr( _r + 48 ) + _hex; } _dec = _dec >> 4; } return _hex;

Chciałbym teraz zobaczyć Twoją minę. :D

Jest coś takiego jak FFmpeg, są też binarki na Windowsa, o tu tu. Później wyciągnij sobie bin/ffmpeg.exe do jakiegoś oddzielnego katalogu i tam z linii komend daj tak: ffmpeg -i input.avi frame-%d.jpg Za input.avi wstaw nazwę pliku do przetworzenia. W razie czego CTRL+C przerywa pracę programu. EDIT Ewentualnie użyj Shil Help Pack! Umieść plik AVI w katalogu i uruchom start.bat.

GML time = current_time; repeat 100000000 //------------------------------------------------------------------------------------------------------------------ var _x; _x = 2323; jakis_wzorek = _x +_x *_x - _x; //------------------------------------------------------------------------------------------------------------------ time_diff = current_time - time; time2 = current_time; repeat 100000000 //------------------------------------------------------------------------------------------------------------------ var _jakas_kompletnie_niepotrzebna_tymczasowa; jakis_wzorek = c_stala +c_stala *c_stala - c_stala; //------------------------------------------------------------------------------------------------------------------ time_diff2 = current_time - time2; Taaa... :gnysek: :borek: :ranmus: :psichix:

Musisz sprawdzić czy w miejscu, do którego idzie jednostka, jest wolne. Jeśli nie jest to powinna poszukać innego wolnego miejsca lub się zatrzymać.

Nie mówię o przeniesieniu tylko dodaniu. Po za tym miałeś brak rzutowania na int. No i nie wiem. Jestem prawie na 100% pewny, że masz coś nie tak z tymi tablicami. EDIT struct BUILD_PLACE { int kat; int budynek; }; class CLASS_PLANET { public: int wlasciciel; int a; BUILD_PLACE* build_place; CLASS_PLANET::CLASS_PLANET() { wlasciciel=0; } void init_buildplace( int ilosc_buildplace ) { build_place = new BUILD_PLACE[ilosc_buildplace]; for(int a=0;a<ilosc_buildplace;a++){ build_place[a].budynek=0; build_place[a].kat=0; } } }; class CLASS_DB { public: CLASS_PLANET* planet; CLASS_DB::CLASS_DB( int ilosc_planet ) { planet= new CLASS_PLANET[ilosc_planet]; } }; Bez CLASS_PLANET* i BUILD_PLACE* przed tworzeniem tablic dla pól obiektów. Najwyżej możesz dodać this->.

Tam nigdy nie zwróci true tylko id obiektu, jak już != noone, ale też szybciej. :D

Najprościej? To co napisałeś spróbuj uruchomić pod C++. Znaczy piszesz main i... no po prostu testujesz, tylko w C++. EDIT #include "DGE_DB.h" CLASS_DB db(100); export double DGE_init_buildplace( double numer_planety, double ilosc ) { db.planet[(int)numer_planety].init_buildplace( (int)ilosc ); return 0; } export double DGE_edit_buildplace( double numer_planety, double numer_buildplace, double katczybudynek, double wartosc ) { if( katczybudynek == 1 ) // 1- ustalenie pozycji buildplacu { db.planet[(int)numer_planety].build_place[(int)numer_buildplace].kat=(int)wartosc; // <----------- TA linijka powoduje blad } else // 0 - ustalenie numeru budynku { db.planet[(int)numer_planety].build_place[(int)numer_buildplace].budynek=(int)wartosc; } return 0; } ?

A, widzisz. Brakowało mi tego. W takim wypadku być może problem leży po stronie tablic. Bo to, że Ci się kompiluje to jeszcze nic. Jak wyskakujesz poza rozmiar tablicy to może być to problem.

Read https://gmclan.org/index.php?czytajart=36

Dokładnie! I wiesz co, z ciekawości sprawdziłem obie metody wydajnościowo. Zgadnij, która była szybsza. Twoja. O 0,6%, GM jest śmieszny. :)

1. Generalnie mp_potential_step sam z siebie to mało. Przydało by się stworzenie jakiejś siatki po której Twoje jednostki mogły by się poruszać. Przejrzyj funkcje mp_... 2. Grupuj. Niech grupa podąża do celu w jakiejś formacji. Bo tu problemem jest, że każda jednostka ma ten sam punkt docelowy no i próbuje go osiągnąć.

Człowieku, nie piszesz w C, nie piszesz w Pascalu tylko w GMLu. Jemu to obojętne. I uwierz, nie tylko dla mnie. Dla większości początkujących to bez różnicy i to nawet lepiej. Dla Ciebie ta korzyść, że będzie Ci łatwiej uczyć się C czy PHP czy innego C like, a minus, że przy Pascalu będziesz szukał błędów przy warunkach.

Powiedziałeś właśnie, że nie powinno się używać = w warunkach, w GML, który czerpie ze składni Pascala tak samo jak i z C. GML w warunkach tak samo traktuje == jak i =, dodatkowo dokumentacja nie precyzuje, który z zapisów jest poprawny i powinien być wykorzystywany - pewnie dlatego, że oba są poprawne i nie ma tutaj konkretnych wymagań. Brak związku logicznego z dyskusją.

Negacja binarna to nie to samo co negacja logiczna. GM określa liczby za pomocą zmiennoprzecinkowej liczby podwójnej precyzji, a najgorsze jest to, że GM przy operatorach binarnych liczby zmiennoprzecinkowe konwertuje na 64 bitowe liczby całkowite - ze znakiem oczywiście. Tak czy inaczej, 1 binarnie wygląda tak: 0000000000000000000000000000000000000000000000000000000000000001 = 1 Teraz, jeśli zanegujesz te 1 to otrzymasz: 1111111111111111111111111111111111111111111111111111111111111110 = ~1 = -2 I to w sumie wszystko.