Tutorial LPC - Historia wersji

Falerok: /* DODATEK B. Rodzaje obrażeń */

2018-12-22T17:23:22Z

DODATEK B. Rodzaje obrażeń

← poprzednia wersja		Wersja z 17:23, 22 gru 2018
Linia 5083:		Linia 5083:

	== DODATEK B. Rodzaje obrażeń ==		== DODATEK B. Rodzaje obrażeń ==
	W_IMPALE rany ~~klute~~		W_IMPALE rany kłute
	W_SLASH rany ~~ciete~~		W_SLASH rany cięte
	W_BLUDGEON obuchowe		W_BLUDGEON obuchowe

	W_NO_DT brak ~~obrazen~~		W_NO_DT brak obrażeń
	MAGIC_DT ~~obrazenia~~ magiczne		MAGIC_DT obrażenia magiczne

	[[Kategoria:Mechanika Arkadii]]		[[Kategoria:Mechanika Arkadii]]

Falerok: /* DODATEK A. Formanty odmiany polskiej */

2018-12-22T17:22:57Z

DODATEK A. Formanty odmiany polskiej

← poprzednia wersja		Wersja z 17:22, 22 gru 2018
Linia 5059:		Linia 5059:
	1) odmiana przez przypadki		1) odmiana przez przypadki
	PL_MIA 0 - mianownik		PL_MIA 0 - mianownik
	PL_DOP 1 - ~~dopelniacz~~		PL_DOP 1 - dopełniacz
	PL_CEL 2 - celownik		PL_CEL 2 - celownik
	PL_BIE 3 - biernik		PL_BIE 3 - biernik
	PL_NAR 4 - ~~nadrzednik~~		PL_NAR 4 - nadrzędnik
	PL_MIE 5 - miejscownik		PL_MIE 5 - miejscownik

	np. ~~chcac poznac imie~~ gracza w bierniku stosujemy		np. chcąc poznać imię gracza w bierniku stosujemy
	this_player()->query_name(PL_BIE);		this_player()->query_name(PL_BIE);
	lub		lub
Linia 5072:		Linia 5072:
	2) rodzaje gramatyczne		2) rodzaje gramatyczne

	PL_MESKI_OS 0 - wskazuje na ~~odmiane meska osobowa~~ obiektu (osoba tu oznacza ~~istote zywa myslaca~~, np. elf, ogr ale nie kot)		PL_MESKI_OS 0 - wskazuje na odmianę męską osobową obiektu (osoba tu oznacza istotę żywą myślącą, np. elf, ogr ale nie kot)
	PL_MESKI_NOS_ZYW 1 - wskazuje na ~~odmiane nieosobowa~~ dla istoty ~~zywej~~ (np. kota)		PL_MESKI_NOS_ZYW 1 - wskazuje na odmianę nieosobową dla istoty żywej (np. kota)
	PL_MESKI_NOS_NZYW 2 - wskazuje na ~~odmiane nieosobowa~~ dla przedmiotu (np. ~~dlugopis~~)		PL_MESKI_NOS_NZYW 2 - wskazuje na odmianę nieosobową dla przedmiotu (np. długopis)
	PL_MESKI_NZYW 2 - to samo co PL_MSESKI_NOS_NZYW		PL_MESKI_NZYW 2 - to samo co PL_MSESKI_NOS_NZYW

	PL_ZENSKI 3 - wskazuje na ~~odmiane zenska~~		PL_ZENSKI 3 - wskazuje na odmianę żeńską

	PL_NIJAKI_OS 4 - wskazuje na ~~odmiane nijaka osobowa~~		PL_NIJAKI_OS 4 - wskazuje na odmianę nijaką osobową
	PL_NIJAKI_NOS 5 - wskazuje na ~~odmiane nijaka nieosobowa~~		PL_NIJAKI_NOS 5 - wskazuje na odmianę nijaką nieosobową

	== DODATEK B. Rodzaje obrażeń ==		== DODATEK B. Rodzaje obrażeń ==

Falerok: /* Korzystanie z wewnętrznej dokumentacji */

2018-12-22T17:20:34Z

Korzystanie z wewnętrznej dokumentacji

← poprzednia wersja		Wersja z 17:20, 22 gru 2018
Linia 4974:		Linia 4974:
	=== Korzystanie z wewnętrznej dokumentacji ===		=== Korzystanie z wewnętrznej dokumentacji ===

	Na ~~zakonczenie slow~~ kilka o ~~wewnetrznej~~ dokumentacji muda, gdzie ~~znalezc mozna~~ zazwyczaj ~~mnostwo~~ przydatnych rzeczy [~~zalezy~~ to ~~glownie~~ od ~~administratorow~~ muda i ~~osob zajmujacych sie dokumentacja~~ ;)]		Na zakończenie słów kilka o wewnętrznej dokumentacji muda, gdzie znaleźć można zazwyczaj mnóstwo przydatnych rzeczy [zależy to głównie od administratorów muda i osób zajmujących się dokumentacją ;)]

	Efunkcje, sfunkcje i lfuns opisano w ~~manulach dostepnych~~ pod ~~komenda~~ ‘man’. ~~Mozna oczywiscie wyszukiwac~~ za ~~pomoca~~ odpowiedniej opcji ~~interesujace~~ nas funkcje. Ponadto w kilku ~~rozdzialach~~ opisano ~~rozne~~ przydatne rzeczy. [~~szczegoly~~ ?man]		Efunkcje, sfunkcje i lfuns opisano w manualach dostępnych pod komendą ‘man’. Można oczywiście wyszukiwać za pomocą odpowiedniej opcji interesujące nas funkcje. Ponadto w kilku rozdziałach opisano różne przydatne rzeczy. [szczegóły ?man]

	~~Przykladowo~~ chcemy ~~pobrac~~ user id obiektu, ale nie ~~pamietamy dokladnie~~ jaka funkcja jest za to odpowiedzialna. ~~Pamietamy~~ jednak, ze jej nazwa ~~konczyla sie~~ literami ‘id’!		Przykładowo chcemy pobrać user id obiektu, ale nie pamiętamy dokładnie jaka funkcja jest za to odpowiedzialna. Pamiętamy jednak, że jej nazwa kończyła się literami ‘id’!

	> man -k *id		> man -k *id
Linia 4985:		Linia 4985:
	export_uid geteuid getuid seteuid setuid		export_uid geteuid getuid seteuid setuid

	Widzimy zatem, ze wyszukiwarka ~~znalazla piec~~ funkcji ~~odpowiadajacych~~ podanemu kryterium. ~~Wyswietlono wszyskie pasujace~~ wyniki, po przeszukaniu wszystkich stron man.		Widzimy zatem, że wyszukiwarka znalazła pięć funkcji odpowiadających podanemu kryterium. Wyświetlono wszystkie pasujące wyniki, po przeszukaniu wszystkich stron man.

	Wiemy ~~juz~~, ~~ze chodzilo~~ o getuid. By ~~poczytac~~ o niej wpisujemy man getuid (lub nawet man simul_efun getuid – efekt ~~bedzie~~ w tym przypadku taki sam).		Wiemy już, że chodziło o getuid. By poczytać o niej wpisujemy man getuid (lub nawet man simul_efun getuid – efekt będzie w tym przypadku taki sam).

	~~Doswiadczeni programisci~~ LPC ~~znaja~~ na ~~pamiec powiazania~~ funkcji i wiedza co ~~dziedziczyc~~ by ~~uzyskac~~ do ~~porzadany~~ efekt. Wie ~~takze~~ mniej ~~wiecej~~ jakie funkcje zawarte sa w danym obiekcie, ~~oczywiscie~~ nie zna wszystkich.		Doświadczeni programiści LPC znają na pamięć powiązania funkcji i wiedza co dziedziczyć by uzyskać do pożądany efekt. Wie także mniej więcej jakie funkcje zawarte są w danym obiekcie, oczywiście nie zna wszystkich.
	~~Kazdy~~ koder przeto powinien ~~czesto korzystac~~ z komendy ‘sman’. Stanowi on kolekcje ~~naglowkow~~ funkcji zawartych w kodzie z /cmd, /lib, /obj, /secure, /std i /sys.		Każdy koder przeto powinien często korzystać z komendy ‘sman’. Stanowi on kolekcje nagłówków funkcji zawartych w kodzie z /cmd, /lib, /obj, /secure, /std i /sys.

	~~Takze~~ tutaj ~~mozliwe~~ jest przeszukiwanie smanu wg podanych ~~kryteriow~~ [~~szczegoly~~ ?sman].		Także tutaj możliwe jest przeszukiwanie smanu wg podanych kryteriów [szczegóły ?sman].

	~~Przykladowo~~, chcemy ~~znalezc funkcje ktora~~ zwraca ~~nazwe~~ gildii zawodowej do ~~ktorej~~ dany gracz ~~nalezy~~. Nie wiemy jednak jaki obiekt definiuje ja ani jak ~~sie~~ ta funkcja zwie.		Przykładowo, chcemy znaleźć funkcję która zwraca nazwę gildii zawodowej do której dany gracz należy. Nie wiemy jednak jaki obiekt definiuje ja ani jak się ta funkcja zwie.

	> sman -k guild		> sman -k guild
Linia 5048:		Linia 5048:
	query_guild_pref_total set_guild_stat		query_guild_pref_total set_guild_stat

	W ~~gaszczu~~ funkcji odnajdujemy ~~te jedna~~, a ~~szczegoly~~ odczytamy ~~uzywajac~~ komendy sman /std/guild/guild_occ_sh query_guild_name_occ.		W gąszczu funkcji odnajdujemy tę jedną, a szczegóły odczytamy używając komendy sman /std/guild/guild_occ_sh query_guild_name_occ.

	Z czasem lepiej będziesz orientować się w Mudlibie i łatwiej będzie ci tak formułować zapytanie, żeby otrzymać wystarczająco zawężoną odpowiedź za pierwszym razem. Nie żeby było coś złego w parokrotnym przeszukiwaniu, od tego w końcu jest sman!		Z czasem lepiej będziesz orientować się w Mudlibie i łatwiej będzie ci tak formułować zapytanie, żeby otrzymać wystarczająco zawężoną odpowiedź za pierwszym razem. Nie żeby było coś złego w parokrotnym przeszukiwaniu, od tego w końcu jest sman!

	:''' Koniec ~~czesci glownej~~ Manualu LPC ...		:''' Koniec części głównej Manualu LPC ...
	:''' ~~Uzupelnienie~~ by Kael		:''' Uzupełnienie by Kael

	== DODATEK A. Formanty odmiany polskiej ==		== DODATEK A. Formanty odmiany polskiej ==

Falerok: /* Zapętlanie alarmów */

2018-12-22T17:12:35Z

Zapętlanie alarmów

← poprzednia wersja		Wersja z 17:12, 22 gru 2018
Linia 4931:		Linia 4931:
	==== Zapętlanie alarmów ====		==== Zapętlanie alarmów ====

	Przyjrzyjmy ~~sie nastepujacej~~ funkcji:		Przyjrzyjmy się następującej funkcji:

	public void		public void
Linia 4940:		Linia 4940:
	}		}

	Co ~~bedzie~~ efektem ~~wywolania~~ tej funkcji? ~~Otoz~~, co ~~sekunde bedzie~~ generowany nowy alarm, ~~wywolujacy~~ siebie samego co ~~sekunde~~. Co to oznacza? ~~Spojrzmy~~ na opis ~~efektow~~:		Co będzie efektem wywołania tej funkcji? Otóż, co sekundę będzie generowany nowy alarm, wywołujący siebie samego co sekundę. Co to oznacza? Spójrzmy na opis efektów:

	1 sekunda:		1 sekunda:
	Buu! 0 (oryginalne ~~wywolanie~~)		Buu! 0 (oryginalne wywołanie)
	2 sekunda:		2 sekunda:
	Buu! 1 (~~powtorzenie~~ 1 sek 0)		Buu! 1 (powtórzenie 1 sek 0)
	Buu! 1 (nowe od 1 sek 0)		Buu! 1 (nowe od 1 sek 0)
	3 sekunda:		3 sekunda:
	Buu! 1 (~~powtorzenie~~ 1 sek 0)		Buu! 1 (powtórzenie 1 sek 0)
	Buu! 2 (~~powtorzenie~~ 2 sek 1)		Buu! 2 (powtórzenie 2 sek 1)
	Buu! 2 (~~powtorzenie~~ 2 sek 1)		Buu! 2 (powtórzenie 2 sek 1)
	Buu! 2 (nowe od 2 sek 1)		Buu! 2 (nowe od 2 sek 1)
	Buu! 2 (nowe od 2 sek 1)		Buu! 2 (nowe od 2 sek 1)
	4 sekunda:		4 sekunda:
	Buu! 1 (~~powtorzenie~~ 1 sek 0)		Buu! 1 (powtórzenie 1 sek 0)
	Buu! 2 (nowe od 3 sek 1)		Buu! 2 (nowe od 3 sek 1)
	Buu! 2 (~~powtorzenie~~ 2 sek 1)		Buu! 2 (powtórzenie 2 sek 1)
	Buu! 2 (~~powtorzenie~~ 2 sek 1)		Buu! 2 (powtórzenie 2 sek 1)
	Buu! 3 (~~powtorzenie~~ 3 sek 2)		Buu! 3 (powtórzenie 3 sek 2)
	Buu! 3 (~~powtorzenie~~ 3 sek 2)		Buu! 3 (powtórzenie 3 sek 2)
	Buu! 3 (~~powtorzenie~~ 3 sek 2)		Buu! 3 (powtórzenie 3 sek 2)
	Buu! 3 (~~powtorzenie~~ 3 sek 2)		Buu! 3 (powtórzenie 3 sek 2)
	Buu! 3 (nowe od 3 sek 2)		Buu! 3 (nowe od 3 sek 2)
	Buu! 3 (nowe od 3 sek 2)		Buu! 3 (nowe od 3 sek 2)
Linia 4969:		Linia 4969:
	... itd.		... itd.

	Jak ~~widac~~ przyrost jest tutaj lawinowy, co w ~~krotkim~~ czasie doprowadzi do padu gry. Taka praktyka jest tak ~~glupia ze~~ konsekwencje dla czarodzieja, ~~ktory~~ by ~~cos~~ takiego lub podobnego ~~zrobil bylyby~~ bardzo ostre.		Jak widać przyrost jest tutaj lawinowy, co w krótkim czasie doprowadzi do padu gry. Taka praktyka jest tak głupia że konsekwencje dla czarodzieja, który by coś takiego lub podobnego zrobił byłyby bardzo ostre.
	~~Oczywiscie~~ na obecnym etapie rozwoju ~~wiekszosc~~ LPMudów jest zabezpieczona przed ~~uzyciem~~ partykularnie ~~tozsamej~~ konstrukcji.		Oczywiście na obecnym etapie rozwoju większość LPMudów jest zabezpieczona przed użyciem partykularnie tożsamej konstrukcji.

	=== Korzystanie z wewnętrznej dokumentacji ===		=== Korzystanie z wewnętrznej dokumentacji ===

Falerok: /* Mappingi/Tablice – bezpieczeństwo */

2018-12-22T17:09:44Z

Mappingi/Tablice – bezpieczeństwo

← poprzednia wersja		Wersja z 17:09, 22 gru 2018
Linia 4923:		Linia 4923:
	rada_po_moich_poprawkach = OBIEKT_GILDIOWY->zwroc_rade();		rada_po_moich_poprawkach = OBIEKT_GILDIOWY->zwroc_rade();

	rada_po_moich_poprawkach += ({ "olorin" }); // I dodaje Olorina do rady gildii i ~~kazdy~~		rada_po_moich_poprawkach += ({ "olorin" }); // I dodaje Olorina do rady gildii i każdy
	// ~~moze~~ to ~~zrobic~~!		// może to zrobić!
	}		}

	Jak to zatem ~~poprawic~~? Wystarczy ~~zmodyfikowac funkcje~~ zwroc_rade, by ~~zwracala~~ return Rada + ({}); i wszystko ~~bedzie~~ w ~~porzadku~~. ~~Latwo przegapic~~, a ~~jakiez~~ to ~~wazne~~!		Jak to zatem poprawić? Wystarczy zmodyfikować funkcję zwroc_rade, by zwracała return Rada + ({}); i wszystko będzie w porządku. Łatwo przegapić, a jakież to ważne!

	==== Zapętlanie alarmów ====		==== Zapętlanie alarmów ====

Falerok: /* Pułapki i niuanse */

2018-12-22T17:01:05Z

Pułapki i niuanse

← poprzednia wersja		Wersja z 17:01, 22 gru 2018
Linia 4896:		Linia 4896:
	=== Pułapki i niuanse ===		=== Pułapki i niuanse ===

	Przy kodowaniu nie trudno o ~~pomylke~~. ~~Czesto~~ kod ~~wyglada~~ na nasze oko ~~ladnie~~, ale tak ~~naprawde~~ jest szalenie nieefektywny. W tym rozdziale ponownie zajmiemy ~~sie czesto popelnianymi bledami~~.		Przy kodowaniu nie trudno o pomyłkę. Często kod wygląda na nasze oko ładnie, ale tak naprawdę jest szalenie nieefektywny. W tym rozdziale ponownie zajmiemy się często popełnianymi błędami.

	Wiele z tych ~~bledow juz~~ opisano we ~~wczesniejszych rozdzialach~~, ale nie zaszkodzi ~~powtorzyc~~.		Wiele z tych błędów już opisano we wcześniejszych rozdziałach, ale nie zaszkodzi powtórzyć.

	==== Mappingi/Tablice – bezpieczeństwo ====		==== Mappingi/Tablice – bezpieczeństwo ====

	Problem jak wspomniano w rozdziale 2.2.9 polega na tym, ze mappingi i tablice nie sa kopiowane, za ~~kazdym~~ razem gdy sa przenoszone. Operacje ~~odbywaja sie~~ jedynie na ~~wskazniku~~. ~~Moze~~ to ~~byc~~ podstawa do wielu niebezpiecznych luk w kodzie.		Problem jak wspomniano w rozdziale 2.2.9 polega na tym, że mappingi i tablice nie są kopiowane, za każdym razem gdy są przenoszone. Operacje odbywają się jedynie na wskaźniku. Może to być podstawa do wielu niebezpiecznych luk w kodzie.

	Przyjrzyjmy ~~sie przykladowi~~ obiektu gildiowego, ~~ktory~~ zajmuje ~~sie czlonkami~~ gildii. Globalna zmienna Rada, ~~ktora~~ jest zapisywana przez save_object() zawiera ~~rade~~ gildii.		Przyjrzyjmy się przykładowi obiektu gildiowego, który zajmuje się członkami gildii. Globalna zmienna Rada, która jest zapisywana przez save_object() zawiera radę gildii.

	string *Rada;		string *Rada;
Linia 4914:		Linia 4914:
	}		}

	~~Wyglada~~ to na ~~prawidlowe~~, lecz tak ~~naprawde~~ zwraca jedynie ~~wskaznik~~ do oryginalnej tablicy. ~~Jesli ktos~~ inny zechce ~~dodac czlonka~~ do rady gildii ~~moze~~ to ~~zrobic~~! wystarczy, taka sztuczka:		Wygląda to na prawidłowe, lecz tak naprawdę zwraca jedynie wskaźnik do oryginalnej tablicy. Jeśli ktoś inny zechce dodać członka do rady gildii może to zrobić! wystarczy, taka sztuczka:

	void		void

Falerok: /* Słów kilka o makrodefinicjach */

2018-12-22T16:55:27Z

Słów kilka o makrodefinicjach

← poprzednia wersja		Wersja z 16:55, 22 gru 2018
Linia 4858:		Linia 4858:
	==== Słów kilka o makrodefinicjach ====		==== Słów kilka o makrodefinicjach ====

	~~Czesto popelnianym bledem~~ jest umieszczanie ~~DUZYCH~~ tablic i/lub ~~mappingow~~ jako makrodefinicji. ~~Wyobrazmy~~ sobie jeden wielki mapping ~~zawierajacy~~ definicje rang gildiowych, opisy, ~~przerozne~~ limity ~~umiejetnosci mozliwych tamze~~ do wytrenowania, modyfikatory, etc, gdzie ranga gildiowa ~~spelnia~~ funkcje indeksu. Bardzo ~~czesto~~ trzeba ~~sie bedzie~~ do niego ~~odwolywac~~, przez centralny obiekt administracyjny gildii, etc. Mamy ~~cos~~ takiego:		Często popełnianym błędem jest umieszczanie DUŻYCH tablic i/lub mappingów jako makrodefinicji. Wyobraźmy sobie jeden wielki mapping zawierający definicje rang gildiowych, opisy, przeróżne limity umiejętności możliwych tamże do wytrenowania, modyfikatory, etc, gdzie ranga gildiowa spełnia funkcje indeksu. Bardzo często trzeba się będzie do niego odwoływać, przez centralny obiekt administracyjny gildii, etc. Mamy coś takiego:

	// ~~Gorna~~ partia pliku		// Górna partia pliku

	#define GUILD_MAP ([ 0: ({ "~~poczatkujacy~~", "~~troche~~", 3, 2343, ... }), \		#define GUILD_MAP ([ 0: ({ "początkujący", "trochę", 3, 2343, ... }), \
	1: ({ .... \		1: ({ .... \
	... /* i dalej ~~okolo~~ 20 lub ~~wiecej~~ podobnych linijek */ \		... /* i dalej około 20 lub więcej podobnych linijek */ \
	])		])

	// kodowy ~~przyklad uzycia~~		// kodowy przykład użycia
	write("Masz obecnie range: " + GUILD_MAP[rank][1] + "\n");		write("Masz obecnie range: " + GUILD_MAP[rank][1] + "\n");
	// dalszy kod		// dalszy kod

	~~Spojrz~~ na to czytelniku ~~uwaznie~~. ~~Przypomne~~ w tym miejscu co ~~daja~~ makrodefinicje: ~~otoz dzialaja nastepujaca~~, ~~ilekroc~~ podczas wykonywania programu system napotka na ~~wzor~~ podany przy makrodefinicji (tu: GUILD_MAP) zamienia go przez ~~rozwiniecie~~ podane w makrodefinicji (tu: ~~caly~~ ten mapping). ~~Krotko~~: ~~ilekroc uzyjemy odwolania~~ do GUILD_MAP wstawiany jest calutki mapping. Za ~~kazdym~~ razem gdy go wstawiamy driver musi ponownie ~~interpretowac~~ jego ~~zawartosc~~, ~~sortowac~~ i ~~indeksowac~~. Jest to zatem strasznie nieoptymalne, ~~pamieciozerne~~ i ~~czasochlonne~~.		Spójrz na to czytelniku uważnie. Przypomnę w tym miejscu co dają makrodefinicje: otóż działają następująco, ilekroć podczas wykonywania programu system napotka na wzór podany przy makrodefinicji (tu: GUILD_MAP) zamienia go przez rozwinięcie podane w makrodefinicji (tu: cały ten mapping). Krótko: ilekroć użyjemy odwołania do GUILD_MAP wstawiany jest calutki mapping. Za każdym razem gdy go wstawiamy driver musi ponownie interpretować jego zawartość, sortować i indeksować. Jest to zatem strasznie nieoptymalne, pamięciożerne i czasochłonne.

	Zamiast makrodefinicji o wiele efektywniej ~~mozna~~ to ~~zrobic~~ tak, ~~uzywajac~~ zmiennej:		Zamiast makrodefinicji o wiele efektywniej można to zrobić tak, używając zmiennej:

	// ~~Gorna~~ partia pliku		// Górna partia pliku

	mapping GuildMap;		mapping GuildMap;
Linia 4883:		Linia 4883:
	// kod		// kod

	GuildMap = ([ 0: ({ "~~poczatkujacy~~", "~~troche~~", 3, 2343, ... }), \		GuildMap = ([ 0: ({ "początkujący", "trochę", 3, 2343, ... }), \
	1: ({ .... \		1: ({ .... \
	... /* i dalej ~~okolo~~ 20 lub ~~wiecej~~ podobnych linijek */ \		... /* i dalej około 20 lub więcej podobnych linijek */ \
	]);		]);

	}		}

	// kodowy ~~przyklad uzycia~~		// kodowy przykład użycia
	write("Masz obecnie ~~range~~: " + GuildMap[rank][1] + "\n");		write("Masz obecnie rangę: " + GuildMap[rank][1] + "\n");
	// dalszy kod...		// dalszy kod...

Falerok: /* Efektywne pętle */

2018-12-22T16:42:36Z

Efektywne pętle

← poprzednia wersja		Wersja z 16:42, 22 gru 2018
Linia 4807:		Linia 4807:

	Ten temat może się wydawać raczej trywialny. W końcu na ile sposobów		Ten temat może się wydawać raczej trywialny. W końcu na ile sposobów
	można zapisać pętle? Raczej na niewiele. Zacznijmy od ~~najczestszego bledu~~.		można zapisać pętle? Raczej na niewiele. Zacznijmy od najczęstszego błędu.
	~~Zalozmy~~, ze mamy ~~jakas duza~~ tablice, nazwijmy ja ‘wielka_tab’ i ~~zalozmy~~,		Załóżmy, że mamy jakąś dużą tablice, nazwijmy ją ‘wielka_tab’ i załóżmy,
	ze chcemy ‘~~przeleciec~~’ ~~petla~~ przez wszystkie jej elementy. Co robisz w takiej		że chcemy ‘przelecieć’ pętlą przez wszystkie jej elementy. Co robisz w takiej
	sytuacji? &bdquo;Proste!” ~~wyjasniasz~~, &bdquo;~~Oczywiscie~~, ~~ze zwykla petla~~ ‘for’!”.		sytuacji? &bdquo;Proste!” wyjaśniasz, &bdquo;Oczywiście, że zwykła pętla ‘for’!”.
	Pewnie... Ale jak to zapiszesz? ~~Najczesciej~~ ludzie ~~robia~~ to w ten ~~sposob~~:		Pewnie... Ale jak to zapiszesz? Najczęściej ludzie robią to w ten sposób:

	int i;		int i;
Linia 4817:		Linia 4817:
	for (i = 0 ; i < sizeof(wielka_tab) ; i++)		for (i = 0 ; i < sizeof(wielka_tab) ; i++)
	{		{
	// Tu robimy ~~cos~~ z ~~tablica~~		// Tu robimy coś z tablicą
	}		}

	No tak... a ~~wiec~~ co jest ~~zle~~? ~~Jesli~~ przejrzysz ~~rozdzial mowiacy~~		No tak... a więc co jest źle? Jeśli przejrzysz rozdział mówiący
	o ~~dzialaniu~~ instrukcji ‘for’, to zobaczysz, ze wykonywane sa trzy ~~czesci~~		o działaniu instrukcji ‘for’, to zobaczysz, że wykonywane są trzy części
	w ~~okraglych~~ nawiasach oddzielone ~~srednikami~~. Pierwsza tylko na ~~poczatku~~,		w okrągłych nawiasach oddzielone średnikami. Pierwsza tylko na początku,
	druga (~~srodkowa~~) za '''~~kazdym~~''' cyklem ~~petli~~ i trzecia ~~rowniez~~ za ~~kazdym~~ razem		druga (środkowa) za '''każdym''' cyklem pętli i trzecia również za każdym razem
	na ~~koncu kazdego~~ cyklu.		na końcu każdego cyklu.

	Oznacza to, ze funkcja ‘sizeof()’ zostaje wykonana za ~~kazdym~~ cyklem ~~petli~~.		Oznacza to, że funkcja ‘sizeof()’ zostaje wykonana za każdym cyklem pętli.
	Jest to raczej ~~marnotrastwo~~, ~~biorac~~ pod ~~uwage~~ fakt, ze tablice rzadko		Jest to raczej marnotrawstwo, biorąc pod uwagę fakt, że tablice rzadko
	~~zmieniaja~~ rozmiar. ~~Jesli~~ by ~~robily~~ to ~~czesto~~, ~~bylaby~~ to inna para kaloszy,		zmieniają rozmiar. Jeśli by robiły to często, byłaby to inna para kaloszy,
	ale jako ze nie ~~robia~~... Nie. Napisz to w ten ~~sposob~~:		ale jako że nie robią... Nie. Napisz to w ten sposób:

	int i, sz;		int i, sz;
Linia 4835:		Linia 4835:
	for (i = 0, sz = sizeof(wielka_tab) ; i < sz ; i++)		for (i = 0, sz = sizeof(wielka_tab) ; i < sz ; i++)
	{		{
	// Tu robimy ~~cos~~ z ~~tablica~~.		// Tu robimy coś z tablicą.
	}		}

	Widzisz? Zmienne ‘i’ oraz ‘sz’ tylko na ~~poczatku dzialania petli maja~~		Widzisz? Zmienne ‘i’ oraz ‘sz’ tylko na początku działania pętli mają
	przypisywane ~~wartosci~~. Licznik ‘i’ zostaje ustawiony na 0, a zmiennej		przypisywane wartości. Licznik ‘i’ zostaje ustawiony na 0, a zmiennej
	‘sz’ zostaje przypisany rozmiar tablicy. Przez ~~caly~~ czas ~~dzialania~~		‘sz’ zostaje przypisany rozmiar tablicy. Przez cały czas działania
	~~petli porownywane sa~~ same zmienne, zamiast ~~ciaglego~~ obliczania		pętli porównywane są same zmienne, zamiast ciągłego obliczania
	nie ~~zmieniajacego sie~~ rozmiaru tablicy.		nie zmieniającego się rozmiaru tablicy.

	~~Mozesz~~ mi ~~wierzyc~~ albo nie, ale to jest bardzo ~~czesty blad~~, prawie		Możesz mi wierzyć albo nie, ale to jest bardzo częsty błąd, prawie
	~~kazdy~~ go robi. ~~Oszczednosci~~ w moim sposobie ~~moga sie~~ nie ~~wydawac~~ tak		każdy go robi. Oszczędności w moim sposobie mogą się nie wydawać tak
	wielkie... ale... ~~pomnoz~~ to razy wszystkie ~~petle~~ w mudzie i przez ~~liczbe~~		wielkie... ale... pomnóż to razy wszystkie pętle w mudzie i przez liczbę
	razy kiedy sa wykonywane, a otrzymasz ~~calkiem niezla liczbe~~. Kosztem		razy kiedy są wykonywane, a otrzymasz całkiem niezłą liczbę. Kosztem
	drugiego sposobu w ~~porownaniu~~ do pierwszego jest dodanie jednej zmiennej		drugiego sposobu w porównaniu do pierwszego jest dodanie jednej zmiennej
	lokalnej i to jest ~~wystarczajaco mala~~ cena.		lokalnej i to jest wystarczająco mała cena.

	~~Pamietaj~~ o tym problemie nie tylko w przypadku tablic, ale ~~rowniez~~		Pamiętaj o tym problemie nie tylko w przypadku tablic, ale również
	w mappingach lub innych ~~ogolnych~~ pojemnikach, ~~zawierajacych~~ rzeczy, przez		w mappingach lub innych ogólnych pojemnikach, zawierających rzeczy, przez
	~~ktore~~ chcesz ‘~~przeleciec~~’ ~~petla~~. ~~Rozwiazanie~~, z ~~wyjatkiem malych roznic~~		które chcesz ‘przelecieć’ pętlą. Rozwiązanie, z wyjątkiem małych różnic
	w rozpoznawaniu rozmiaru pojemnika jest zawsze takie same.		w rozpoznawaniu rozmiaru pojemnika jest zawsze takie same.

Falerok: /* 3.2 Pisanie efektywnego kodu */

2018-12-22T16:29:30Z

3.2 Pisanie efektywnego kodu

← poprzednia wersja		Wersja z 16:29, 22 gru 2018
Linia 4799:		Linia 4799:
	=== 3.2 Pisanie efektywnego kodu ===		=== 3.2 Pisanie efektywnego kodu ===

	Ten temat jest blisko ~~powiazany~~ z tym co ~~powiedzialem wczesniej~~, ze		Ten temat jest blisko powiązany z tym co powiedziałem wcześniej, że
	'''nie''' ~~bede wyjasniac~~ jak ~~programowac~~. Wycofam swe ~~slowa~~ – ~~troszeczke~~ –		'''nie''' będę wyjaśniać jak programować. Wycofam swe słowa – troszeczkę –
	i opowiem o kilku sprawach co ~~robic~~, albo nawet co ~~wazniejsze~~, czego '''nie'''		i opowiem o kilku sprawach co robić, albo nawet co ważniejsze, czego '''nie'''
	~~robic~~.		robić.

	==== Efektywne pętle ====		==== Efektywne pętle ====

	Ten temat ~~moze sie wydawac~~ raczej trywialny. W ~~koncu~~ na ile ~~sposobow~~		Ten temat może się wydawać raczej trywialny. W końcu na ile sposobów
	~~mozna zapisac petle~~? Raczej na niewiele. Zacznijmy od najczestszego bledu.		można zapisać pętle? Raczej na niewiele. Zacznijmy od najczestszego bledu.
	Zalozmy, ze mamy jakas duza tablice, nazwijmy ja ‘wielka_tab’ i zalozmy,		Zalozmy, ze mamy jakas duza tablice, nazwijmy ja ‘wielka_tab’ i zalozmy,
	ze chcemy ‘przeleciec’ petla przez wszystkie jej elementy. Co robisz w takiej		ze chcemy ‘przeleciec’ petla przez wszystkie jej elementy. Co robisz w takiej

Falerok: /* Złożenia funkcji i kompleksowe struktury */

2018-12-22T16:11:20Z

Złożenia funkcji i kompleksowe struktury

← poprzednia wersja		Wersja z 16:11, 22 gru 2018
Linia 4711:		Linia 4711:
	==== Złożenia funkcji i kompleksowe struktury ====		==== Złożenia funkcji i kompleksowe struktury ====

	W tym miejscu ~~wazne~~ jest, by czytelnik ~~poruszal sie zrecznie~~ w ~~plaszczyznach problemow omowionych~~ w poprzednich ~~rozdzialach~~.		W tym miejscu ważne jest, by czytelnik poruszał się zręcznie w płaszczyznach problemów omówionych w poprzednich rozdziałach.
	Pojawia ~~sie~~ pytanie: ‘Co ~~mozna umiescic~~ w ~~wywolanie~~ funkcji tego typu?’.		Pojawia się pytanie: ‘Co można umieścić w wywołanie funkcji tego typu?’.

	Odpowiedz brzmi: ‘Prawie wszystko’.		Odpowiedz brzmi: ‘Prawie wszystko’.

	Jest to ~~oczywiscie zalezne~~ od ~~umiejetnosci wlasnych~~ i ~~gibkosci~~ poruszania ~~sie~~ w ramach kodu.		Jest to oczywiście zależne od umiejętności własnych i gibkości poruszania się w ramach kodu.

	Wiele ~~osob~~ miewa problemy ze zrozumieniem ~~operatorow~~.		Wiele osób miewa problemy ze zrozumieniem operatorów.
	~~Wsrod~~ nich mamy: +, -, *, /, %, &, \|, ^, >>, <<, <, >, <=, >=, ==, !=, [].		Wśród nich mamy: +, -, *, /, %, &, \|, ^, >>, <<, <, >, <=, >=, ==, !=, [].

	~~Dosyc czesto~~ programista chce ~~wykonac jedna operacje~~ i jej wynik ~~przeslac bezposrednio~~ jako argument dla innej.		Dosyć często programista chce wykonać jedną operację i jej wynik przesłać bezpośrednio jako argument dla innej.

	Typ funkcyjny ~~obsluguje superpozycje~~ [~~zlozenie~~] funkcji poprzez operator @.		Typ funkcyjny obsługuje superpozycję [złożenie] funkcji poprzez operator @.

	~~Dziala~~ on jak matematyczne ~~zlozenie~~, od prawej do lewej! Podobnie jak operator.		Działa on jak matematyczne złożenie, od prawej do lewej! Podobnie jak operator.

	Oto ~~przyklad~~, ~~ktory~~, miejmy nadzieje, ~~rozjasni~~ wszystko:		Oto przykład, który, miejmy nadzieje, rozjaśni wszystko:

	Niech pewna tablica zawiera imiona pewnych graczy:		Niech pewna tablica zawiera imiona pewnych graczy:
Linia 4733:		Linia 4733:
	string *arr = ({ "Galarel", "Adren", "Kael", "Aendill", "Thorin", "Hanor" });		string *arr = ({ "Galarel", "Adren", "Kael", "Aendill", "Thorin", "Hanor" });

	Przyjmijmy, ze chcemy docelowo ~~pobrac~~ z tablicy imiona, ~~ktore skladaja sie~~ z ~~wiecej niz pieciu~~ liter. ~~Mozna~~ to ~~oczywiscie zrobic~~ za ~~pomoca petli~~, jak ~~ponizej~~:		Przyjmijmy, że chcemy docelowo pobrać z tablicy imiona, które składają się z więcej niż pięciu liter. Można to oczywiście zrobić za pomocą pętli, jak poniżej:


Linia 4750:		Linia 4750:


	~~Oczywiscie~~, ~~mozna uzyc~~ efunkcji filter:		Oczywiście, można użyć efunkcji filter:

	int		int
Linia 4764:		Linia 4764:
	}		}

	Ale w takim przypadku ~~musze pisac osobna~~ funkcje ~~filtrujaca~~. Na ~~szczescie mozna pojsc~~ jeszcze dalej, do efektownego zapisu jednolinijkowego !		Ale w takim przypadku muszę pisać osobną funkcje filtrującą. Na szczęście można pójść jeszcze dalej, do efektownego zapisu jednolinijkowego !
	// ... tu mamy zdefiniowana tablice arr		// ... tu mamy zdefiniowana tablice arr

	result = filter(arr, &operator(<)(5) @ strlen);		result = filter(arr, &operator(<)(5) @ strlen);

	UWAGA! Niezmiernie ~~wazne~~ jest tu ~~wywolanie~~ operator(). Jak ~~powiedzielismy~~ przebiega ono od prawej do lewej, przeto dochodzi do momentu, gdy program ma do czynienia z ~~nastepujacym porownaniem~~: 5 < strlen(name).		UWAGA! Niezmiernie ważne jest tu wywołanie operator(). Jak powiedzieliśmy przebiega ono od prawej do lewej, przeto dochodzi do momentu, gdy program ma do czynienia z następującym porównaniem: 5 < strlen(name).

	Teraz nieco skomplikujemy sytuacje. Chcemy ~~pojsc~~ dalej i ~~pobrac~~ z tablicy ~~wylacznie Smiertelnikow~~ [~~ktorych~~ imiona ~~skladaja sie~~ z ~~conajwyzej pieciu znakow~~.]		Teraz nieco skomplikujemy sytuacje. Chcemy pójść dalej i pobrać z tablicy wyłącznie Śmiertelników [których imiona składają się z co najwyżej pięciu znaków.]

	~~Oczywiscie~~ jest to proste i ~~wyglada nastepujaco~~:		Oczywiście jest to proste i wygląda następująco:

	// ... tu mamy zdefiniowana tablice arr		// ... tu mamy zdefiniowana tablice arr
Linia 4780:		Linia 4780:
	&operator(==)(0) @ SECURITY->query_wiz_rank);		&operator(==)(0) @ SECURITY->query_wiz_rank);

	Tutaj rozszerzono po prostu ~~wywolanie~~ o kolejne ~~zlozenie~~, przy ~~wczesniejszym~~ pobraniu ~~osob~~ o imionach o ~~dlugosci~~ do 5 ~~znakow~~.		Tutaj rozszerzono po prostu wywołanie o kolejne złożenie, przy wcześniejszym pobraniu osób o imionach o długości do 5 znaków.

	~~Pojdzmy~~ dalej. Jak ~~myslisz~~ co ~~sie~~ stanie gdy wykonasz ~~nastepujace~~ polecenie? Co pojawi ~~sie~~ na ekranie?		Pójdźmy dalej. Jak myślisz co się stanie gdy wykonasz następujące polecenie? Co pojawi się na ekranie?

	exec return implode(sort_array(map(filter(users(), sizeof @		exec return implode(sort_array(map(filter(users(), sizeof @
Linia 4788:		Linia 4788:
	deep_inventory)->query_real_name(), capitalize)), ", ");		deep_inventory)->query_real_name(), capitalize)), ", ");

	Na pewno ~~wiekszosci czytelnikow~~ wydaje ~~sie~~ to ~~prosciutkie~~.		Na pewno większości czytelników wydaje się to prościutkie.

	Opisze, co ~~sie~~ tu ~~dzialo~~. Po pierwsze, przebiegamy przez wszystkich graczy [w tym ~~czarodziejow~~] i przeszukujemy ~~cale~~ ich ekwipunki. Filtruje osoby, ~~ktore posiadaja tarcze~~ i pobieram ich imiona. Tablice ~~wynikow~~ sortuje, ~~przeksztalcam~~ by ~~byly~~ napisane z wielkiej litery i tworze ~~zen~~ jeden string z ~~przecinikiem~~ (,) po ~~kazdym~~ imieniu. W rezultacie na ekranie pojawia ~~sie~~ ten ~~wlasnie~~ string.		Opisze, co się tu działo. Po pierwsze, przebiegamy przez wszystkich graczy [w tym czarodziejów] i przeszukujemy całe ich ekwipunki. Filtruje osoby, które posiadają tarczę i pobieram ich imiona. Tablice wyników sortuje, przekształcam by były napisane z wielkiej litery i tworze z nich jeden string z przecinkiem (,) po każdym imieniu. W rezultacie na ekranie pojawia się ten właśnie string.

	Innymi ~~slowy~~: otrzymuje spis ~~osob~~, ~~ktore maja~~ przy sobie tarcze.		Innymi słowy: otrzymuje spis osób, które mają przy sobie tarcze.

	:'''UWAGA!''' Czas na ~~przestroge~~. ~~Oczywiscie gladko otrzymalem liste osob~~, ~~majacych~~ w ekwipunku tarcze (nawet ~~jesli~~ jest w plecaku). Jednak ~~zwrocmy uwage~~, ze przy ~~duzej~~ liczbie graczy liczba ~~obiektow~~, ~~ktore~~ maja przy sobie ~~osiaga~~ wielkie ~~pulapy~~, ~~moze~~ nawet kilka ~~tysiecy~~! I teraz na ~~kazdym~~ z nich ~~wywolujemy~~ funkcje sprawdzania czy to tarcza. Jak ~~widac~~ cala operacja jest niezwykle ~~pamieciozerna~~, na ~~szczescie~~ potrzeba przeprowadzenia podobnej operacji rzadko ~~sie~~ zdarza.		:'''UWAGA!''' Czas na przestrogę. Oczywiście gładko otrzymałem listę osób, mających w ekwipunku tarcze (nawet jeśli jest w plecaku). Jednak zwróćmy uwagę, że przy dużej liczbie graczy liczba obiektów, które maja przy sobie osiąga wielkie pułapy, może nawet kilka tysięcy! I teraz na każdym z nich wywołujemy funkcje sprawdzania czy to tarcza. Jak widać cala operacja jest niezwykle pamięciożerna, na szczęście potrzeba przeprowadzenia podobnej operacji rzadko się zdarza.
	Chodzi ~~glownie~~ o to by ~~juz~~ na etapie pisania kodu ~~przewidywac~~ jakie ~~beda~~ konsekwencje jego ~~uzycia~~.		Chodzi głównie o to by już na etapie pisania kodu przewidywać jakie będą konsekwencje jego użycia.

	=== 3.2 Pisanie efektywnego kodu ===		=== 3.2 Pisanie efektywnego kodu ===