Tutorial LPC

Wersja tekstowa z wyszczególnionym autorstwem rozdziałów znajduje się na stronie MUD-a Barsawia. Tu znajduje się ładnie, w założeniu, sformatowana i w wielu miejscach poprawiona wersja HTML.

This is a tutorial for LPC and basic LPmud mudlib.

  The document was written for the Genesis driver and Genesis mudlib.
Gamedriver version CD.04.02, Mudlib CD.00.31 though in all likelyhood
it will still be usable for three-four versions further.

  Copyright (C) 1996 Ronny Wikh

  The use of this manual in any commercial venture is expressly
forbidden, neither may it be offered as inducement to purchase other
services or products.

  Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved in full on all copies.

  Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.

  Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that this permission notice may be stated in a
translation approved by the holders of the above copyright.

Przetlumaczyli na polski / Translated into polish:

• Alvin.Arkadia [arkadia (@) arkadia.rpg.pl] (25/08/96)
• Kael.Barsawia [barsawia (@) irc.pl] (28/02/03)

Przedmowa

LPC

Granie w LPMudy jest bardzo ekscytujacym zajeciem, a ich tworzenie jeszcze bardziej. Jest bardzo niewiele rzeczy, ktorych nie da się zakodować. Nieraz trzeba jednak uzywac roznych sztuczek. Najwiekszą zaleta MUD-ów jest naturalnie to, ze moze w nie grac naraz wielu graczy; widok setek, a nawet tysięcy ludzi uzywajacych i czerpiacych radosc z Twojego kodu sprawia wielka przyjemnosc.

Ten podrecznik ma na celu nauczenie Cie niezbednych podstaw potrzebnych do tworzenia kodu w LPMudach i na Genesis w szczegolnosci. Nie jest to jednak latwa lektura, wiec spodziewaj sie, ze zajmie Ci kilka ladnych dni przyswojenie sobie tego, czego sprobuje Cie nauczyc. Pomimo tego groznie brzmiacego ostrzezenia, zycze Ci przyjemnego kodowania, po tym, jak juz przelamiesz pierwsze lody.

-- Ronny Wikh, 25 styczen 1996

Warunki rozpowszechniania

Podrecznik ten zostal napisany w dobrej wierze dla ludzi, ktorzy pisza MUD-y dla wlasnej przyjemnosci. Oznacza to, ze nie bede wymagal zadnych oplat za uzywanie i rozprowadzanie tego tekstu, pod warunkiem, ze taki wlasnie jest cel jego uzytkowania.

W szczegolnosci chce sie upewnic, ze ci, ktorzy czerpia korzysci finansowe z prowadzenia MUD-a nie uzywaja tego dokumentu jako pomocy w zarabianiu pieniedzy.

Notki tłumaczy

Alvin

Tlumaczenie moze byc miejscami niezreczne. Jest tez spora szansa, ze napotkasz jakies bledy. W obu przypadkach wal z nimi prosze do mnie, czyli do Alvina.

Mam nadzieje, ze Ci sie na cos zda to tlumaczenie.

Kael

Wszelkie, bledy, merytoryczne uwagi i propozycje dotyczace tego wydania prosze zglaszac na adres: rafal.dorociak (małpa) wp.pl

Staralem sie uzywac w miare przystepnego jezyka, w partiach, ktore tlumaczylem, nierzadko odbiegajac nieco od oryginalu, tudziez dodajac wlasne uwagi.

Zycze milego korzystania i wielu przyjemnych chwil z kodem. :)

Wstęp

Na poczatku moim zamierzeniem bylo, by dowolna osoba mogla korzystac i uczyc sie z tego dokumentu. Teraz jednak wydaje mi sie to raczej niemozliwe, wiec skoryguje to troszeczke. To jest podrecznik, z ktorego moze korzystac kazdy, kto ma przynajmniej blade pojecie o programowaniu oraz checi do nauki. Nie musisz znac C zanim zaczniesz i mam nadzieje, ze nawet kompletni laicy beda w stanie sie nauczyc kodowania, choc oczywiscie beda mieli o wiele wiecej roboty.

Doswiadczeni programisci, a nawet ci, ktorzy pisali juz kiedys mudy beda musieli zaznajomic sie z tym podrecznikiem, gdyz wyjasnia on pojecia charakterystyczne tylko dla tej gry, aczkolwiek beda mogli po prostu przejrzec wiekszosc tekstu i skupic sie na bardziej zawilych fragmentach. Tobie, czytelniku, zostawiam wybor tego co jest dla Ciebie wazne, a co nie, gdyz chyba tylko Ty wiesz czego sie jeszcze powinienes nauczyc.

Jako, ze jezyk LPC w aktualnej postaci jest mocno powiazany z mudlibem, ktory jest w nim napisany, zahacze rowniez o jego czesc. Jednakze nie bede Cie uczyl szczegolowo jak z niego korzystac – bedziesz musial przeczytac inne podreczniki. Wszystko to czyni ten dokument wyspecjalizowanym na LPMudy, a na Genesis w szczegolnosci. Pamietaj o tym, jesli piszesz pod innym mudem.

Mam nadzieje, ze ten podrecznik okaze sie pomocny i warty wysilku, ktory trzeba poswiecic na jego przeczytanie. Z pewnoscia napisanie go nie bylo takie proste, wiec niech lepiej jego lektura nie bedzie bezowocna! :)

Podziękowania

Chcialbym zaczac od podziekowan dla Thorstena Lockerta, Christiana Markusa i Bobby'ego Bodenheimera (znanych raczej jako Plugh, Olorin i Plarry), za pomoc przy korekcie tekstu, wartościowe sugestie i ogólnie za wsparcie i pomocna dlon w czasie tworzenia tego podrecznika.

Bez nich realizacja tego ciągnącego się projektu zajęłaby jeszcze wiecej czasu (niewiarygodne, ale bardzo prawdziwe), a koncowy efekt bylby znacznie gorszy.

Mnóstwo ludzi na Genesisie przyczyniła się do kształtu tego tutoriala i z wdzięcznością wspominam o ich cennych sugestiach i pytaniach, ukazujących co ludzie chcieliby wiedzieć o LPC.

Forma podręcznika

Podrecznik jest podzielony na trzy rozdzialy, o rosnacym stopniu zaawansowania. Pierwszy rozdzial wyjasni podstawy kodowania i LPC bez zaglebiania sie w szczegoly.

Drugi rozdzial traktuje o trudniejszych sprawach; wyjasni w pelni wszystkie aspekty funkcji i operatorow, ktore mogly zostac troszeczke zbyt pobieznie potraktowane w rozdziale pierwszym.

Trzeci, koncowy rozdzial traktuje o tym, co moglo zostac pominiete w dwoch poprzednich. Tak na prawde, to nie o wszystkim; podrecznik nie wyjasni wszystkich zawilosci gamedrivera i mudliba. Jesli szukasz informacji o tworzeniu wlasnego mudliba albo o robieniu innych bardzo zaawansowanych rzeczy, bedziesz musial sam do tego dojsc, czytajac kod zrodlowy.

Jesli jestes poczatkujacym wizardem, mozesz byc troche przytloczony na poczatku, patrzac na ten obszerny podrecznik. Jednakze jest wazne, zebys przeczytal wszystko i nie zostawial niczego na pozniej. Bez watpienia bedziesz musial poznac zagadnienia ze wszystkich trzech rozdzialow, choc przewaznie bedziesz korzystal z wiedzy zawartej w dwoch pierwszych. Kurcze! Jest wielu starych wizardow, ktorzy ledwo co opanowali pierwszy rozdzial! Jest to jeden z podstawowych powodow, dla ktorych pisze ten podrecznik...

Ten podrecznik jest dosc rozlegly, pomimo tego, ze jest przeznaczony tylko do nauki kodowania w domenach. Oznacza to, ze nie jest to kompletna instrukcja LPC. Kilka rzadziej uzywanych efunkcji jest pominiętych, gdyz sa one uzywane tylko przez ludzi piszacych oraz ulepszajacych mudliba i gamedrivera. Przykro mi, jesli wlasnie tego tu szukales – bedziesz sie musial rozejrzec za jakims innym zrodlem informacji.

Mala uwaga o plci. Przez caly czas uzywam meskiego rodzaju. Nie dlatego, ze dyskrimunuje programistki, ale dlatego, ze jezyk angielski jest nastawiony na meski rodzaj. (przyp. tlum. hmm.. nie jestem pewien jak z polskim, ale to co autor dalej pisze to prawda) Mysle, ze moglbym za kazdym razem dopisywac tez zenska forme, lecz uwazam, ze byloby to troche glupawe. Dopoki angielski nie stanie sie w pelni neutralnym plciowo jezykiem, bede sie trzymal meskiego rodzaju.

Rozdzialy, ktore szegolowo opisuja efunkcje/sfunkcje/lfunkcje/makra, beda mialy wymienione w nawiasach odwolania do nazw powiazanych z omawianymi rzeczami, aby ulatwic Ci pozniejsze wyszukiwanie tych informacji.

Historia LPC

LPC jest jezykiem programowania MUD-ów, stworzonym przez Larsa Pensjoego na potrzeby wlasnego pomyslu LPMuda, interaktywnego, wieluzytkownikowego srodowiska, przeznaczonego do kilku roznych celow, wsrod ktorych gra nie byla jedynym. Od czasu pierwszego pojawienia sie go, w 1988 roku, jezyk znacznie sie zmienil.

Prace nad nim zostaly przejete okolo 1990 roku, przez innych ludzi z Chalmers Datofrerening, glownie przez Jakoba Hallena, Lennarta Augustssona i Andersa Chrigstroema. Rozszezyli i udoskonalili znacznie jezyk, aczkolwiek, jak nazwa LPC wskazuje, wciaz wykazuje on powiazania z jezykiem ‘C’. Roznice glownie polegaja na dolaczeniu struktury obiektowej, jak rowniez na dodaniu kilku typow danych, w celu uprzystepnienia programowania. LPC nie jest tak swobodnym jezykiem jak klasyczny ‘C’, choc z drugiej strony bardziej sie nadaje do celu, dla jakiego zostal stworzony – do pisania srodowiska gry.

Gamedriver/Mudlib

Definicja roznicy pomiedzy gamedriverem i mudlibem moze sie zdawac trudna do okreslenia, lecz tak na prawde jest bardzo prosta. Gamedriver jest to program, ktory jest uruchomiony na serwerze muda. Jest interpreterem polecen polaczonym z jadrem zarzadzania obiektami (object management kernel). Mozna nawet powiedziec, ze jest to swoisty system operacyjny. Definiuje i rozumie jezyk LPC, interpretuje i wykonuje instrukcje podane mu poprzez obiekty LPC. Gamedriver zajmuje się tylko obliczeniami i wszelka treść MUD-a jest mu podawana z zewnątrz do uruchomienia.

Mudlib jest biblioteką podstawowych obiektów LPC wspólnych dla całej gry. Zawiera zestaw obiektow LPC, ktore sa uzywane w grze: ogólny obiekt gracza, potwora, pokoju itd. To co Ty piszesz, czyli kod domenowy, jest przechwowywane i obslugiwane osobno i korzysta z podstawowych elementów środowiska gry umieszczonych w mudlibie.

Struktura administracyjna

Mozna powiedziec, ze gra jest podzielona na trzy charakterystyczne czesci, tak jak to juz zostalo powyzej zasugerowane; Gamedriver, mudlib i „kod domenowy”. Gamedriver i mudlib juz zostaly opisane. Domeny sa sposobem na zorganizowanie pisanania kodu. Domena to grupa wizardow, pracujacych ku z gory okreslonemu celowi. Moze nim byc jakas ograniczona przestrzen, fragment swiata gry, lub rzeczy takie jak gildie badz sekty, ktorych czlonkami gracze moga zostac.

W kazdej domenie jest jeden szef, Lord domeny. Jest on swego rodzaju nadzorca. Decyduje co sie w domenie ma dziac i w jakim kierunku prace powinny zdazac. W domenie caly kod moze byc latwo wymieniany i jest mocno ze soba powiazany.

Oczywiscie, sa rowniez wiezy pomiedzy roznymi domenami, aczkolwiek sa one zazwyczaj slabsze, a kod jest rzadko wymieniany.

Jako poczatkujacy wizard, bedziesz probowal znalezc sobie jakas domene, w ktorej praca wyda ci sie interesujaca i inspirujaca.

Pisanie kodu

Moze sie wydac nieco przedwczesnym mowienie Ci jak kod powinien wygladac, zanim nawet nie nauczyles sie jak go pisac. Jednakze jest to fundamentalna sprawa o wielkiej waznosci. Ktos fajnie powiedzial, ze wlasciwe pisanie kodu uczyni Twe zeby bielszymi, wlosy ciemniejszymi i pozytywnie wplynie na twoje zycie seksualne. Tego chyba nie moge zagwarantowac, ale na pewno drastycznie polepszy to jakosc, tego co piszesz, przy bardzo niskich nakladach pracy. Polega to glownie na samodyscyplinie.

Oto kilka dobrych argumentow na pisanie poprawnego kodu:

• Czyni Twoj kod znacznie bardziej przejrzystym, nie tylko dla innych, lecz rowniez dla Ciebie, szczegolnie jesli sam bedziesz musial przeczytac i poprawic go szesc miesiecy po tym, jak go napisales.

• Jesli jest on bardziej przejrzysty dla innych, to latwiej im bedzie zrozumiec to, co skleciles i co za tym idze latwiej bedzie im pomoc ci w razie problemow.

• Wlasciwe pisanie kodu czyni go lepszym, mozesz wierzyc lub nie. Przyczyna jest prosta: niepoprawne pisanie programu zwieksza bardzo szanse na to, ze przeoczysz jakies banalne bledy, schowane posrod scisnietego kodu.

• Moze ci byc naprawde ciezko znalezc ludzi, ktorzy beda chcieli odpluskwic zle sformatowany kod. Ja osobiscie nie pomoge osobom w usunieciu bledow z programu, ktory wyglada okropnie. Przyczyna jest prosta: jest to gra nie warta swieczki. W zle wygladajacym kodzie kryje sie wiele glupich bledow (przewaznie brakujace, albo przemieszczone nawiasy), ktore wyjda na wierzch od razu po tym, jak wlasciwie sformatujesz program.

Teraz bedzie troche przydluga instrukcja mowiaca o tym, jak nalezy ukladac kod w czasie pisania. Przeczytaj to, nawet jesli w pelni nie rozumiesz o czym jest mowa, a pozniej wroc i przeczytaj raz jeszcze po tym, jak zdobedziesz niezbedne umiejetnosci. W ten sposob utrwali Ci sie wlasciwy sposob pisania programow.

1. Jedno wciecie ma dlugosc 4 spacji, nie mniej, nie wiecej. Nowe wciecie zaczyna sie na poczatku kazdego bloku.
2. Pomiedzy slowami kluczowymi a otwierajacym nawiasem ‘(’, jesli takowy jest, powinna byc jedna spacja.

       while (test)
           wyrazenie;

3. Nawiasy otwierajace i zamykajace ten sam blok powinny byc w tej samej kolumnie; w kolumnie pierwszej litery wyrazenia otwierajacego blok.

       if (to)
       {
           wyrazanie;
       }
       else if (tamto)
       {
           inne_wyrazenie;
       }
       else
       {
           standardowe_wyrazenie;
       }
   

   Natrafiamy teraz na punkt o prawie religijnym znaczeniu dla niektorych programistow. Przedstawiciele innej sekty wyznaja, ze nawias otwierajacy blok powinien znajdowac sie na koncu lini z wyrazeniem otwierajacym blok. Rob tak jak ja mowie, albo utkniesz w tym cholernym COBOLu na zawsze :) Teraz na serio, wybierz jedna metode i trzymaj sie jej. Jest na prawde bardzo wazna rzecza to, abys utrzymywal te sama dlugosc wciecia przez caly czas. Zmienne dlugosci wciec to cos, co nie moze byc tolerowane.

4. Liczne argumenty oddzielone od siebie przecinkami, maja po kazdym takowym jedna spacje. Listy argumentow oddzielone ‘;’ i operatory numeryczne maja po jednej spacji przed i po operatorze.

       int a, b, c;
   
       for (a = 0; a < 10; a++)
       {
           b = function_call(a, b * 2);
           c = b * 3 / 4;
       }

5. Jesli wyrazenie petli jest puste, umiesc konczacy ‘;’ w oddzielnej linii. while (!(zmienna = funkcja(zmienna))) ; Przyczyna jest to, ze jakbys umieszczal ‘;’ w tej samej linii, byloby bardzo latwo przeoczyc prawdziwe bledy takie jak ten, wynikajacy z czystego lentistwa.

       for (i = 0 ; i < 100 ; i++);
       {
           <ten blok jest wykonywany tylko raz, i to za kazdym razem>
       }

6. Wszystkie wyrazenia ‘#define’ i ‘#include’ powinny byc umieszczone na samym poczatku pliku. Mozliwe jest ich rozrzucenie, lecz to tylko gmatwa.
7. To samo z prototypami funkcji i zmiennymi typu global/static. Zbierz je do kupy, z odpowiednim komentarzem w naglowku i umiesc na poczatku pliku. Oczywiscie mozesz je rozrzucic po calym pliku, ale jakze latwe bedzie przeoczenie ich pozniej...
8. Przy deklaracji funkcji, typ zwracanej wartosci umieszczaj w linii przed nazwa funkcji.

       public void
       moja_funkcja(int a, int b)
       {
           < kod >
       }

9. Lam dlugie linie kodu w odpowiednich miejscach tak, zeby nie wychodzily poza 80-znakowy ekran. Wyglada to potwornie i ciezko sie to czyta, nie mowiac o problemach zwiazanych z pozniejszym drukowaniem.
10. Plik powinien sie zaczynac nastepujacym naglowkiem:

        /*
        * <nazwa pliku>
        *
        * <Krotki opis tego co plik robi, nie wiecej niz 5-7 linii.
        * ...
        * ... >
        *
        * Copyright (C): <twoje imie, nazwisko i rok>
        *
        */

    Juz TERAZ przeczytaj prawa autorskie, by wiedziec jakie zasady obowiazuja co do kodu, ktory piszesz dla gry. Powininny one sie znajdowac w pliku ‘/doc/COPYRIGHT’. Jesli ich tam nie ma, to po prostu spytaj jednego z administratorow gry. (przyp. tlum. U nas jeszcze nie ma czegos takiego i nie bedzie do czasu az ktos nie napisze ;) )

11. Kazda funkcje zaczynaj od naglowka, ktory wyglada tak:

        /*
        * Nazwa funkcji: <Nazwa funkcji>
        * Opis:          <Krotki opis tego, co funkcja robi, zazwyczaj
        *                 nie wiecej niz trzy linie. >
        * Argumenty      <Lista wszystkich argumentow, jeden na linie
        *                   arg1 - opis nie dluzszy niz jedna linia.
        *                   arg2 - nastepny argument, itd. >
        * Zwraca:        <Co funkcja zwraca>
        */

    Jesli funkcja nie potrzebuje zadnych argumentow, lub nie zwraca niczego, to po prostu usun te linie z naglowka.
12. Umiesc stosowne komentarze przy kodzie tu i owdzie, tam gdzie uznasz, ze moze on byc niezrozumialy. Pamietaj rowniez o tym, ze na twoim (zakladanym) poziome kompetencji wiele rzeczy moze sie wydawac niezrozumialymi :) Czyn wedlug wlasnego uznania.

        /*
        * Komentarz poprzedzajacy kod, 
        * opisujacy co on robi
        */
        < kod >

13. Upewnij sie, ze nazwy funkcji i zmienne lokalne sa zapisane malymi literami alfabetu, z ewentualnymi odstepami pomiedzy wyrazami w postaci podkreslenia (np. ‘nazwa_funkcji()’). Zmienne globalne powinny miec duze pierwsze litery slow (np. ‘int GlobalTime;’). ‘#define’ powinny byc zapisane duzymi literami (np. ‘#define AMEBA "jednokomorkowe zyjatko"’). W ten sposob latwo bedzie rozpoznac, jaki jest to rodzaj symbolu. Najprostszym sposobem zalapania w jaki sposob nalezy pisac, jest uzywanie edytora emacs, ustawionego na tryb c++. Taki tryb rozumie operatory ‘::’, aczkolwiek wymaga kilku podpowiedzi w materii tabulacji itp. Umiesc te linie w pliku .emacs i wszystko powinno dzialac jak powinno:

    W oryginalnym tutorialu ta lista jest dłuższa, nie znam się na emacsie więc nie wiem czy to istotne.

        ;; emacs lisp script start
         
        (setq auto-mode-alist (append '(
          ("\\.l" . my-c++-mode)
          ("\\.y" . my-c++-moe)
          ("\\.c" . my-c++-mode)
          ("\\.h" . my-c++-mode))
            auto-mode-alist))
         
        (defun my-c++-mode () (interactive)
          (c++-mode)
          (setq c-indent-level 4)
          (setq c-brace-offset 0)
          (setq c-label-offset -4)
          (setq c-continued-brace-offset -4)
          (setq c-continued-statement-offset 4))
          ;; emacs end

    Emacs ma jeszcze wbudowana mozliwosc, ktora sie przydaje przy odpluskwianiu wypocin innych ludzi. Poprawienie wciec w kodzie jest tak proste, jak wstukanie ‘M-<’, ‘M->’, ‘M-x indent-region’.

Wprowadzenie do LPC

Ten rozdzial nauczy cie zupelnych podstaw programowania, potrzebnych do zrozumienia calosci. Oprocz tego wprowadzi cie w programowanie obiektowe oraz opisze kawalek mudliba.

Podstawowe zagadnienia związane z programowaniem

Zaczynamy od podstawowych zagadnien zwiazanych z programowaniem, struktura i srodowiskiem LPC.

Co to jest programowanie?

To jest calkiem filozoficzne pytanie. Trzymajmy sie jednakze praktycznej strony i zostawmy caly bitowy zen tym, ktorzy sie tym zajmuja.

W zasadzie programowanie to sztuka identyfikowania problemu i zamieniania rozwiazania w symbole, ktore komputer jest w stanie zrozumiec. Dobry programista ma wysoko rozwinieta zdolnosc widzenia, jak problem moze byc podzielony na mniejsze problemiki, z ktorych kazdy mozna rozwiazac na kilka sposobow. Wie on takze, ktore z rozwiazan jest najefektywniejsze i powinno byc uzyte w danej sytuacji, biorac pod uwage szybkosc dzialania i zuzycie pamieci.

Programista, jak juz poprzednio zasugerowalem, mowi komputerowi jak rozwiazac problem. Maszyna nie moze sama wymyslic rozwiazania. Jednakze jest ona o wiele szybsza od czlowieka, wiec problemy ktore mozesz rozwiazac, ale ktore zajelyby ci to mnostwo czasu, sa szybciutko rozwiazywane przez komputer.

To, czego musisz sie nauczyc, to sposob myslenia, ktory umozliwi ci ‘rozbijanie’ problemow na kroki, ktore musisz wykonac od stanu poczatkowego do rozwiazanego problemu. Musisz takze poznac metody czynienia tych krokow. Naturalnie, ten podrecznik nie nauczy Cie jak programowac, a jedynie przedstawi Ci jezyk, za pomoca ktorego, bedziesz mogl wpisac program.

Kto w takim razie nauczy cie programowania, jesli nie wiesz jak? Hmm.. W pierwszym rzedzie inni wizardzi oraz ty sam. Innymi slowy ciezka praca. Niestety nigdy nie ma zadnych skrotow, niezaleznie od tego, czego potrzebujesz sie nauczyc. Jednakze poniewaz to jest swietna zabawa, miejmy nadzieje ze zdobywanie tych umiejetnosci sprawi Ci wielka frajde.

Kompilowany/interpretowany kod

Programy są niczym więcej, jak tylko plikami zawierającymi zbiór instrukcji zrozumiałych dla komputera. Programować oznacza wpisywać listy komend w taki sposób, by komputer doszedł do zamierzonego przez nas celu. Zazwyczaj program jest kompilowany – tłumaczony – na niskopoziomowy kod wyrażony w symbolach binarnych (wysokie i niskie stany napięć w pamięci komputera), które maszyna rozumie bez problemu. Język, w którym programujesz jest po prostu wygodnym kompromisem, który rozumiesz zarówno Ty jak i komputer. Przyczyna dla której kompilujesz, jest to, ze tłumaczenie kodu jest dość skomplikowane i zajmuje sporo czasu. Lepiej zrobić to raz, przechować wyniki i odwoływać się bezpośrednio do nich w razie potrzeby.

LPC jednakże nie jest kompilowany – jest interpretowany. Instrukcje są czytane i tłumaczone jedna po drugiej, wykonane i zapomniane. W sumie nie jest to tak do końca prawda. W rzeczywistości gamedriver tłumaczy program w LPC do prostej, przejściowej postaci kodu instrukcji. Ten zestaw kodów komend tworzy tak zwany ‘master object’ i jest przechowywany w pamięci komputera. Kiedy uruchamiasz program LPC, instrukcje sa przeglądane linia po linii, tak jak zostało to powyżej opisane, powodując wykonanie poprzednio określonego zestawu czynności zdefiniowanego przez instrukcje.

Różnica pomiędzy posiadaniem zinterpretowanego kodu, a posiadaniem skompilowanego polega na tym, ze o ile skompilowany kod jest szybszy, to zinterpretowana wersja jest o wiele łatwiejsza do zmodyfikowania. Jeśli chcesz dokonać zmiany w skompilowanej wersji, musisz zmienić kod źródłowy, zrekompilować, przechować nowa wersje i dopiero wypróbować. Gdy masz zinterpretowany kod, wystarczy ze zmienisz źródło i uruchomisz go. W LPC musisz jeszcze poinstruować gamedrivera, aby zniszczył stary ‘master object’, ale o tym później.

Programy

Programy LPC, jak zostalo wyzej powiedziane, maja postac plikow zawierajacych instrukcje dla komputera, napisane w jezyku LPC. Ich nazwy musza sie konczyc literami ‘.c’ (np. ‘test.c’), dzieki czemu gamedriver wie z czym ma doczynienia. Nazwa pliku moze byc dowolnym lancuchem znakowym o dlugosci mniejszej niz 32 znaki, zaczynajacym sie od litery alfabetu. W praktyce jednakze, lepiej jest ograniczac nazwy plikow do 16 znakow, na ktore skladaja sie tylko male litery alfabetu. Jesli chcesz by nazwa skladala sie z dwoch slow, mozesz je oddzielic za pomoca znaku ‘_’ (np. ‘moja_nazwa_pliku.c’).

Obiekty

„Obiekt” w LPC jest po prostu załadowaną do pamięci komputera kopia istniejacego programu – jest jednym ucieleśnieniem jakiegoś kodu. Kiedy program jest ladowany do pamieci, by utworzyc „master object”, kod jest kompilowany i wytworza poprzednio opisany zestaw instrukcji. Dolaczany przy tym jest takze maly obszar pamieci przeznaczony dla „zmiennych globalnych” (opisane dalej). Kiedy kopia, „klon” programu jest tworzony, specjalny odnosnik zwany „wskaznikiem obiektu” (object pointer) jest kreowany. Dostaje on adres do master objectu oraz unikalny obszar pamieci. Kiedy klonujesz obiekt jeszcze raz, tworzony jest nowy wskaznik i przydzielana jest nowa pamiec. Gdy obiekt jest niszczony, zaalokowana pamiec zostaje uwolniona, tak aby inne obiekty mogly z niej korzystac. Sam master object, czyli wyzej opisana lista intrukcji zostaje nienaruszona. Obiekt zawsze jest klonowany z master objectu. Jesli chcesz klonowac nowa wersje obiektu, najpierw musisz uaktualnic (update) master object, aby gamedriver wiedzial, ze nowa lista instrukcji ma byc kompilowana ze zmienionego kodu zrodlowego.

W takiej sytuacji, istniejace klony nie beda zmieniane tylko z tego powodu, ze master object ulegl zmianie. Beda mialy odniesienie do starej listy instrukcji. Wazne jest abys pamietal, ze zachowanie starych klonow nie zmienia sie tylko dlatego, ze uaktualniles master object. Jak widzisz jest mozliwe posiadanie klonow obiektow, ktore sie zachowuja roznie, po prostu dlatego, ze sa one skompilowane z roznych zrodel, sklonowane pomiedzy uaktualnieniami i zmianami w kodzie. Moze to byc przyczyna duzych nieporozumien, wiec pamietaj o tym.

Struktura obiektu

Obiekt jest zlozony z „funkcji” i „zmiennych”. Funkcja to zestaw instrukcji, do ktorych mozna sie odwolac za pomoca nazwy. Zmienna to swego rodzaju pojemnik, w ktorym mozna przechowywac dane do uzytku przez funkcje. Kilka funkcji jest zdefiniowane z gory w gamedriverze i sa one nazywane „funkcjami zewnetrznymi” (external functions), albo „efunkcjami” (efuns). Funkcje zdefiniowane w kodzie LPC sa nazywane „lokalnymi funkcjami” (local functions), albo „lfunkcjami&rbdquo; (lfuns). Zeby jeszcze bardziej pogmatwac sprawe sa funkcje, ktore zachowuja sie jak efunkcje, ale sa napisane w kodzie LPC. Sa one zwane „symulowanymi efunkcjami” (simulated efuns), albo „sfunkcjami” (sfuns).

Efunkcja to taka, ktorej sie nie da stworzyc w LPC. Na przyklad funkcja write(), ktora umozliwia wyswietlenie tekstu na ekranie gracza. Niemozliwe jest stworzenie jej z innych funkcji LPC, wiec musi ona byc w gamedriverze. Ta efunkcja jest dostepna dla wszystkich programow LPC. Efunkcje wogole nie wiedza w jakim srodowisku sa uzywane i nie martwia sie o to, czy sa stosowane do symulowania smaku truskawki, czy jako czesc gry.

Funkcja taka jak ‘add_exit()’, ktora dodaje wyjscie z pokoju jest dostepna tylko obiektom typu pokoj i napisano ja w LPC. Lfunkcje z zasady sa czescia struktury srodowiska w jakim obiekty sa uzyte. Nasz przykladowy ‘add_exit()’ swietnie radzi sobie z takimi rzeczami, jak kierunki wyjsc i koszty podrozy(zmeczenie), ale jest ograniczony tylko do tego – nie potrafi nic wiecej.

Funkcja ‘creator()’ jest dobrym przykladem trzeciego rodzaju. Jest ona dostepna wszedzie. Zwraca kto stworzyl podany obiekt. Ta informacja jest jednak bardzo charakterystyczna dla srodowiska, poniewaz uzywa takich pojec jak lokalizacja kodu. Taki rodzaj funkcji jest latwy do napisania w LPC, ale z drugiej strony musi byc dostepny we wszystkich obiektach, tak jak by to byly efunkcje. Z tej przyczyny zostal stworzony specjalny obiekt ‘/secure/simul_efun.c’, ktory jest dostepny ze wszystkich innych obiektow w grze. Znajdziesz tam wszystkie sfunkcje. To wszystko jest w sumie niewidzialne dla ciebie; ty po prostu uzywasz ich jako efunkcji, bez zawracania sobie glowy, ze jest to jakas sfunkcja.

Podstawy LPC

LPC jest bardzo podobny do jezyka C, choc mozna sie dopatrzec kilku roznic. Jak doswiadczony programista zapewne dostrzeze, jest troche uproszczony poprzez dodanie dla wygody kilku nowych typow i zestawu funkcji obslugujacych je. Roznice nie sa jednak na tyle powazne, by mogly spowodowac jakies problemy, o ile sie o nich pamieta.

Komentarze

Moze to troche dziwnie wygladac, ze zaczynam akurat od tego, ale komentarze wystepuja wszedzie, wiec musisz umiec rozpoznawac je od samego poczatku.

Sa dwa typy komentarzy:

    <kod> // To jest komentarz trwajacy do konca tej linii.
    
    <kod> /* To jest komentarz ograniczony */ <kod>

Jak widzisz, pierwszy typ komentarzy zaczyna sie od znakow ‘//’ i trwa az do konca linii. Jesli chcesz miec wiecej linii komentarzy, to musisz na poczatku kazdej napisac ‘//’.

Drugi typ jest taki, ze ma okreslona dlugosc. Zaczyna sie od znakow ‘/*’ i konczy znakami ‘*/’. Ten rodzaj komentarzy jest uzyteczny, gdy chcesz zawrzec tekst, ktory zajmuje wiele linii.

UWAGA! Komentarz ‘/* */’ nie moze byc zagniezdzany, tzn nie mozesz zrobic czegos takiego jak w tym przykladzie:

    /* Komentarz /* Zagniezdzony komentarz */ kontynuacja pierwszego */

W takiej sytuacji komentarz skonczy sie na pierwszym napotkanym ‘*/’, pozostawiajac tekst ‘kontynuacja pierwszego */’ kompilatorowi, ktory bedzie to probowal zinterpretowac tak, jakby to byl kod LPC. Oczywiscie cos takiego nie zadziala i otrzymasz komunikat bledu.

Typy danych

Obiekty przechowuja informacje w „zmiennych”. Jak sama nazwa wskazuje, sa one oznaczonymi schowkami, ktore moga magazynowac informacje, ktore sie zmieniaja od czasu do czasu. Obiekt operuje na nich poprzez funkcje, ktore to zarowno uzywaja jak i zwracaja dane roznych typow.

W zasadzie tylko jeden typ danych jest potrzebny, cos w rodzaju uniwersalnego pojemnika, ktory moze przechowywac cokolwiek zechcesz. W rzeczywistosci jest o wiele lepiej, jesli rozroznisz rozne typy informacji od siebie. Moze sie wydawac, ze to tylko przysparzy ci jeszcze wiecej problemow, ale tak na prawde to redukuje to ryzyko bledu, podnosi czytelnosc oraz znacznie przyspiesza kodowanie i odpluskwianie obiektu.

W LPC jest mozliwosc uzywania tylko danych ‘ogolnego uzytku’, o ktorych wczesniej mowilem. We wczesniejszych wersjach jezyka, byl to jedyny dostepny typ. Jednakze w LPC, ktorego uzywamy dzis, wielce korzystne jest unikanie tego jak sie tylko da. Zaczynaj swe programy ta instrukcja:

    #pragma strict_types

Mowi ona gamedriverowi by sprawdzil wszystkie funkcje, czy sa dostosowane do sytuacji w jakiej sa uzywane i co za tym idzie, czy nie powoduja zadnych bledow. Jest to wielka pomoc we wczesnym wykrywaniu bledow i dzieki temu nie bedziesz musial sie pozniej glowic, kiedy program nie bedzie dzialal do konca tak, jak bys chcial.

Istnieja nastepujace typy danych:

• void

‘nic’

Ten typ danych jest uzywany w funkcjach, ktore nie zwracaja zadnych danych.

• int

‘liczba całkowita’

Dowolna liczba całkowita z szerokiego zakresu, zależnego od mocy komputera, np. od -2147483648 do 2147483647. Może to być choćby 3, 17, -32, 999.

• float

‘liczba zmiennoprzecinkowa’

Dowolna liczba wymierna mieszcząca się w bardzo szerokim zakresie, zależnym od mocy komputera, np. od 1.17549435e-38 do 3.40282347e+38, przykładowo 1.7, -348.4, 4.53e+4.

Jesli sa tu jacys milosnicy FORTRANa, to niech uwazaja na to, ze numery typu ‘1.’ albo ‘.4711’ nie sa rozpoznawane jako zmiennoprzecinkowe. Musicie podac zarowno calkowita, jak i ulamkowa czesc, nawet jesli ktoras z nich jest zerowa.

• string

‘łancuch znakow’

Stringi to po prostu lancuchy znakow (liczb, liter – na przykład słowa), zawarte w angielskich cudzyslowach, np. "x", "lancuch", "Kolejny dlugi lancuch z numerkiem 5 w srodku". Stringi moga zawierac specjalne znaki, takie jak znak nowej linii ("\n"). Wiele wyrazen jezyka LPC moze obslugiwac stringi bezposrednio, w przeciwienstwie do C. Czyni to je bardzo uzytecznymi i latwymi w obsludze.

• mapping

‘Lista powiazan’

Mappingi to kolejny bardzo wygodny wynalazek LPC (uwaga, bardzo pamieciozerny, uzywaj go z umiarem). Mapping jest to lista polaczonych ze soba wartosci. Zalozmy, ze chcesz przechowac wiek kilku osob, np. ze Olek ma 23 lata, Piotr 54, a Ania 17. W LPC mozna to zapisac w ten sposob:

([ "Olek":23, "Piotr":54, "Ania":17 ])

Jak widzisz wartosc po lewej stronie zostala powiazana z wartoscia po prawej. Mozesz wylowic jakies powiazanie, poprzez podanie lewej strony.

• object

‘wskaznik obiektu’

Jest to odnosnik do klonu kodu LPC, ktory jest zaladowany do pamieci.

• function

‘wskaznik funkcji’

Odnosnik do funkcji.

• Array

‘tablica’

Wszystkie powyzsze typy moga wystepowac jako tablice. Wtedy, w definicji, przed nazwa kazdej zmiennej wstawia sie ‘*’, np. ‘int *a, b;’ definiuje dwie zmienne: tablice a oraz pojedyncza zmienna b.

W LPC tablice wygladaja bardziej jak listy, niz jak prawdziwe tablice. Istnieje wiele funkcji, ktore zostaly napisane by przyspieszyc i ulatwic ich obsluge.

• mixed

No i na koniec ogolny typ, ktory zastepuje wszystkie inne, swego rodzaju klucz uniwersalny. Pod zmienne mixed mozna podstawic wartosc dowolnego innego typu. Jeszcze raz powtorze, ze uzywanie go poza sytuacjami, kiedy to jest absolutnie konieczne, tylko prowokuje bledy.

Hmm, jak mi zwrocono uwage, to co napisalem moze brzmiec ciut za surowo. Typ mixed jest calkiem czesto uzywany. Chodzilo mi o to, ze o ile da sie zastosowac jakis normalny typ, to sie go powinno uzyc. Nie zastepuj go zmienną typu mixed tylko dlatego, ze jestes leniwy.

Deklaracje zmiennych

Zmienna jest to lancuch znakow identyfikujacy ‘skrytke’, w ktorej dane sa przechowywane. Skrytka ma podana nazwe, skladajaca sie z maks. 32 znakow, gdzie pierwszy z nich musi byc litera alfabetu. Ustalono, ze wszystkie zmienne zdefiniowane wewnatrz funkcji beda sie skladaly z samych malych liter. Globalne zmienne zas, beda mialy pierwsza litere duza i reszte mala. Ustalono rowniez, ze nie bedzie sie oddzielalo wyrazow znakami innymi niz ‘_’. Nazwy zmiennych zawsze powinny odzwierciedlac to, do czego sa uzywane. Zmienne deklarujemy w nastepujacy sposob:

   <typ danych> <nazwa zmiennej>, <nast. zmienna>, ..., <ostatnia zmienna>;
   np:
       int        licznik;
       float      wysokosc, waga;
       mapping    map_wieku;

Zmienne musza byc zadeklarowane na poczatku bloku (tuz po znaku otwierajacym blok ‘{’), przed kodem wlasciwym. Zmienne globalne, czyli takie, ktore sa dostepne w calym programie, powinny byc zadeklarowane na poczatku pliku.

Kiedy deklaracje sa wykonywane w czasie uruchamiania programu, sa one ustawiane na 0, a NIE na ich ‘puste’(null) wartosci. Innymi slowy np. mappingi, tablice i stringi beda zawsze ustawiane na 0, a nie na ‘([])’, ‘({})’ i ‘""’ tak, jak bys mogl przypuszac. Mozliwe jest zainicjalizowanie zmiennych juz w samej deklaracji. Jest to nawet bardzo dobry zwyczaj.

A robi sie to tak:

    <typ danych> <nazwa zmiennej> = <wartosc>, itp.
    np.
        int        licznik = 8;
        float      wysokosc = 3.0, waga = 1.2;
        mapping    map_wieku = ([]);
        object     *potwory = ({});

Powodem dla ktorego tablice i mappingi powinny byc inicjalizowane na swoje wartosci ‘puste’ (czyli kolejno ‘({})’ i ‘([])’) jest to, ze inaczej beda ustawione na 0, co moze byc przyczyna niekompatybilnosci typow i moze spowodowac pozniej jakies problemy.

Definicje funkcji

Funkcja musi dac znac jaki typ danych zwraca, o ile wogole cos zwraca. Tak jak zmienne, funkcje to sa nazwy skladajace sie z maks. 32 znakow, gdzie pierwszy z nich to litera. Przyjete jest, ze nazwy wszystkich funkcji beda pisane malymi literami, a do oddzielania wyrazow bedzie sie uzywalo tylko znaku ‘_’. Nazywaj funkcje tak, aby jasno odzwierciedlaly to co robia. Deklaracja funkcji wyglada tak:

    /*
     * Nazwa funkcji: <Nazwa funkcji>
     * Opis:          <Co ona robi>
     * Argumenty:     <Lista i krotki opis argumentow>
     * Zwraca:        <Co funkcja zwraca>
     */
    <typ zwracanej wartosci>
    <nazwa funkcji>(<lista argumentow>)
    {
       <kod funkcji>
    }

    /*
     * Function name: oblicz_srednice
     * Description:   Oblicza srednice okregu przy podanym obwodzie
     * Variables:     obwod - obwod okregu
     *                name - nazwa dana okregowi
     * Returns:       Srednice.
     */
    float
    oblicz_srednice(float obwod, string nazwa)
    {
        float rval;
    
        // Obwod = pi * srednica
        rval = obwod / 3.141592643;
        write("Srednica okregu " + nazwa + " wynosi " + ftoa(rval) + "\n");
    
        return rval;
    }

Argumenty sa od siebie oddzielone przecinkami, tak jak w deklaracjach zmiennych. Ustalasz tu jaki typ danych bedzie wyslany do funkcji i kojarzysz nazwe zmiennej z tym typem, do pozniejszego uzytku przez funkcje. Dane z argumentow, beda mogly byc uzyte tylko wewnatrz funckji, no chyba, ze wyslesz je na zewnatrz poprzez wywolanie innej funkcji.

(Zeby zachowac troche miejsca oraz zwiekszyc przejrzystosc podrecznika nie bede umieszczal naglowka przed wszystkimi moimi krotkimi przykladami funkcji).

Funkcja, ktora nie zwraca zadnych danych, powinna miec typ zadeklarowany jako ‘void’.

    void
    write_all(string komunikat)
    {
        users()->catch_msg(komunikat);
    }

Instrukcje i wyrażenia

Zebym mogl cokolwiek wyjasnic, wpierw okresle co oznacza „instrukcja” (statement), a co „wyrazenie” (expression).

Instrukcje

Instrukcja jest swego rodzaju zdaniem, stworzonym z jednego lub wiecej wyrazen. Instrukcje zazwyczaj zajmuja jedna linie kodu. Czasem zachodzi potrzeba zlamania ich gdy sa za dlugie, w celu zwiekszenia czytelnosci. W wiekszosci instrukcji wystarczy, ze zlamiesz je w przerwie pomiedzy dwoma wyrazami. Inaczej jest w lancuchach znakowych – w takim przypadku musisz wstawic backslash (‘\’) na koncu pierwszej lamanej linii. Robi sie to po to, by gamedriver wiedzial co jest grane.

    write("To jest przyklad \
          zlamanego lancucha(stringa).\n");

Jednakze lamanie stringow za pomoca backslasha wyglada bardzo nieladnie i czyni tekst trudnym do przeczytania. Zazwyczaj jest mozliwosc lamania linii naturalnie, na koncu stringa, albo nawet podzielenia lancucha w polowie i dodaniu obu czesci za pomoca operatora ‘+’. Tak naprawde, jedynym miejscem gdzie backslash jest naprawde niezbedny, to instrukcja ‘#define’ – ale o tym pozniej.

    write("To jest lepszy sposob " +
          "lamania stringow.\n");

Instrukcje w LPC zazwyczaj sa zakonczone srednikiem ‘;’. Jest to rowniez dobre miejsce na zakonczenie linii. Nic nie wstrzymuje cie przed zaczynaniem kolejnej instrukcji zaraz po poprzedniej, w tej samej linii, tylko ze wyglada to potwornie.

Wyrażenia

Wyrazenie jest to opis jednej lub wiecej czynnosci, ktorych wykonanie powoduje uzyskanie danych jakiegos rodzaju. Na przyklad taki ‘+’. Uzywa on dwoch wyrazen, ktore w sumie daja jakis wynik. Zmienna tez jest wyrazeniem, poniewaz przechowuje ona dane jako wynik. Nastepujaca kombinacja dwoch wyrazen i operatora tez jest poprawnym wyrazeniem: ‘a + b’ – gdzie ‘a’ oraz ‘b’ sa zmiennymi (wyrazeniami), a ‘+’ jest operatorem. ‘a = b + c;’ jest pelna instrukcja konczaca sie na sredniku ‘;’.

Wywolania funkcji sa poprawnymi wyrazeniami. Sa zapisane w postaci nazwy oraz pary nawiasow, w ktorych znajduja sie argumenty, ktore funkcja wykorzystuje wewnatrz. Na przyklad funkcja ‘max()’, ktora zwraca wyzszy z dwoch podanych argumentow. Aby znalezc wyzsza liczbe, np sposrod ‘4’ i ‘10’, trzeba napisac ‘max(4, 10)’, co zwroci wartosc ‘10’ i dzieki temu mozemy to nazwac wyrazeniem. Oczywiscie warto by jakos ten wynik przechowac.

Instrukcje grupujące (bloki)

Jest wiele instrukcji, na przyklad instrukcje warunkowe, ktore w okreslonych warunkach tylko raz wykonaja podana instrukcje. Zalozmy, ze w takim wypadku chcesz wykonac kilka instrukcji, a nie tylko jedna. Do tego celu istnieje specjalna instrukcja zwana blokiem (instrukcja grupujaca). Znak ‘{’ definiuje poczatek bloku, a ‘}’ jego koniec. Wewnatrz tych nawiasow mozesz umiescic tyle instrukcji (wlaczajac w to definicje zmiennych), ile tylko zechcesz. Instrukcja grupujaca nie konczy sie srednikiem ‘;’ i nic nie zmieni, jesli przez przypadek umiescisz jeden.

Instrukcja ‘;’

Jak juz powiedzialem, ‘;’ jest przewaznie uzywany to zakanczania instrukcji, ale powinienes wiedziec, ze srednik ‘;’ jest rowniez instrukcja sama w sobie.

Sam ‘;’ bedzie po prostu pusta instrukcja, ktora nie powoduje niczego. Jest ona uzyteczna, gdy potrzebujesz zastosowac petle testowe (petle beda opisane pozniej), ktore beda sie tylko wykonywaly (i nie beda robily przy tym zadnych innych rzeczy, jak to zwykle bywa z petlami).

Zasięg i prototypy

„Zasieg” to termin okreslajacy gdzie funkcja lub deklaracja zmiennej jest poprawna. Poniewaz programy sa czytane od gory do dolu, od lewej do prawej (zupelnie tak, jak ty czytasz te strone), zadeklarowane funkcje

i zmienne sa dostepne na prawo i ponizej ich deklaracji. Zasieg ich, moze byc jednak ograniczony.

Zmienna zadeklarowana wewnatrz funkcji, jest dostepna az do znaku zakonczenia bloku ‘}’, w ktorym to ta zmienna jest zdefiniowana.

    < Poczatek pliku >
    int GlownyLicznik;
    
    // Tylko GlownyLicznik jest tu dostepny
    
    void
    var_func(int arg)
    {
        int zmienna_1;
    
        // GlownyLicznik, arg oraz zmienna_1 sa tu dostepne
        < kod >
    
        {
            string zmienna_2;
    
            // GlownyLicznik, arg, zmienna_1 i zmienna_2 sa dostepne w tym
            // bloku
            < kod >
        }
    
        // GlownyLicznik, arg i zmienna_1 sa tu dostepne
        < kod >
    
        {
            int zmienna_2;
            mapping zmienna_3;
    
            // GlownyLicznik, arg, zmienna_1, zmienna_2 oraz zmienna_3 sa tu
            // dostepne
            // *UWAGA* zmienna_2 jest NOWA i nie ma nic wspolnego z ta
            // zdefiniowana funkcje wczesniej
            < kod >
        }
    
        // GlownyLicznik, arg oraz zmienna_1 sa tu dostepne
        < kod >
    }
    
    // Tu tylko GlownyLicznik (i funkcja var_func) jest tu dostepny

Deklaracje funkcji obowiazuje ta sama zasada. Nie mozesz tylko zadeklarowac jednej funkcji wewnatrz drugiej. Wyobraz sobie jednak sytuacje, gdzie masz dwie funkcje i jedna z nich korzysta z drugiej.

    int  /* Definicja func_1. */
    func_1()
    {
        < kod >
        func_2("test"); /* Wywolanie func_2 z argumentem "test". */
    }
    
    void  /* Definicja func_2. */
    func_2(string dane)
    {
        < kod >
    }

I tu natrafiasz na problem, poniewaz pierwsza funkcja probuje wykorzystac druga, zanim tamta jest zadeklarowana. Jesli poinstruowales gamedriver, zeby wymagal zgodnosci typow poprzez napisanie ‘#pragma strict_types’, to wyskoczy ci komunikat bledu. Aby tego uniknac mozesz przekomponowac program w taki sposob, by ‘func_2’ byla zadeklarowana _przed_ ‘func_1’. Czasem jednak nie zawsze jest to mozliwe, a poza tym moze na tym ucierpiec wyglad programu. Jest jeszcze inny, lepszy sposob. Polega on na napisaniu „prototypu funkcji”. Powinien on zostac umieszczony na poczatku pliku, tuz po instrukcjach ‘inherit’ i ‘#include’. Powinien wygladac identycznie jak deklaracja funkcji.

A wiec mamy:

    < poczatek pliku, instrukcje `inherit' i `#include' >
    
    void func_2(string dane);    // <- to jest prototyp funkcji func_2
    
    < definicje zmiennych globalnych, itp. >

    void 
    func_1()
    {
        < kod func_1() >
        func_2("jakis string");  // wywolanie func_2()
    }

    void 
    func_2(string dane)
    {
        < kod funkcji func_2 >
    }

Operatory (operator expressions)

W jezyku LPC jest zdefiniowana spora grupa operatorow, czyli takich cosikow, ktore operuja na wyrazeniach. Bede uzywal pewnego skrotowego sposobu notacji, dzieki ktoremu zaoszczedzi sie sporo miejsca.

• ‘W’

Bedzie oznaczalo dowolne wyrazenie, nawet bardzo pogmatwane.

• ‘Z’

Bedzie oznaczalo jakas zmienna.

Operatory różne

• (W)

W jest obliczane przed robieniem czegokolwiek poza nawiasami. Jest to uzyteczne w izolowaniu wyrazen, ktore trzeba wykonac w jakiejs okreslonej kolejnosci, albo gdy nie jestes pewien jaka jest kolejnosc dzialan (o tym pozniej).

• W1, W2

W1 jest wykonywane jako pierwsze i jego rezultat zostaje zapamietany, wtedy wykonywane jest W2, a jego rezultat jest wyrzucany. Na koniec przechowany rezultat W1 jest zwracany jako wynik calego wyrazenia.

Instrukcja ‘a = 1, 2, 3;’ ustawi wartosc ‘a’ na ‘1’.

• Z = W

Zmienna ma przypisywana wartosc W. Rezultatem calego wyrazenia jest rowniez wartosc W.

‘a = b = 4;’ ustali wartosc a oraz b na 4. Moze to byc tez zapisane w ten sposob:

‘a = (b = 4);’, co ilustruje kolejnosc wykonywania.

Operatory arytmetyczne

• W1 + W2

Wyrazenia sa obliczane i ich rezultaty zostaja do siebie dodane.

Mozesz sumowac ze soba integery, floaty, stringi, tablice i mappingi. Stringi, tablice i mappingi sa po prostu ze soba wiazane – poczatek drugiego jest przylaczany do konca pierwszego argumentu.

Istnieje takze mozliwosc dodawania integerow do stringow. W takiej sytuacji integer bedzie przekonwertowany w stringa i doklejony do niego.

• W1 - W2

W2 jest odejmowane od W1.

Mozesz odejmowac integery, floaty i dowolne tablice, ktore maja ten sam typ. Jesli element z odejmowanej tablicy istnieje w tej, od ktorej sie odejmuje, to jest on po prostu usuwany. Jesli nie ma takowego, to tablica pozostaje nienaruszona.

• W1 * W2

W1 jest mnozone przez W2.

Dziala tylko na integerach i floatach.

• W1 / W2

W1 jest dzielone przez W2.

Dziala tylko na integerach i floatach.

• W1 % W2

Reszta z dzielenia ‘W1 / W2’ jest zwracana.

Dziala to tylko dla integerow.

‘14 % 3’ zwroci 2, poniewaz ‘14 / 3 - 2 = 0’.

• -W

Zwroci W z odwroconym znakiem.

Dziala to tylko dla integerow i floatow.

• W++ (lub ++W)

Zwieksza W o 1.

Jesli plusy znajduja sie przed wyrazeniem, to wyrazenie zwraca nowa wartosc. Jesli sa za wyrazeniem, to zwraca jeszcze stara.

• W-- (lub --W)

Zmniejsza W o 1.

Jesli plusy znajduja sie przed wyrazeniem, to wyrazenie zwraca nowa wartosc. Jesli sa za wyrazeniem, to zwraca jeszcze stara.

Operatory booleanowskie (binarne)

Operatorow booleanowskich mozna uzywac tylko na integerach. Wyjatkiem jest operator ‘&’, ktory moze byc zastosowany rowniez na tablicach. Integer ma dlugosc 32 bitow. Jednakze w przykladach bede ukazywal tylko 10 ostatnich bitow, jako ze pozostale beda mialy wartosc 0 i beda one mogly byc przez to zignorowane, z wyjatkiem operatora ‘~’.

 1. W1 & W2    W1 i W2. (iloczyn logiczny)

               1011101001   (= 745)
               1000100010 & (= 546)
               ------------
               1000100000   (= 544) => 745 & 546 = 544

               Uzyty na dwoch tablicach, zwroci nam nowa tablice 
               zawierajaca wszystkie elementy, ktore wstepuja w obu
               tablicach jednoczesnie.

 2. W1 | W2    W1 lub W2. (suma logiczna)

               1011101001   (= 745)
               1000100010 | (= 546)
               ------------
               1011101011   (= 747) => 745 | 546 = 747

 3. W1 ^ W2    W1 xor (exclusive or - nierownowaznosc; LUB wykluczajace) W2.

               1011101001   (= 745)
               1000100010 ^ (= 546)
               ------------
               0011001011   (= 203) => 745 ^ 546 = 203

 4. ~W         1-complement of E (odwrocenie W).

               00000000000000000000001011101001 ~ (= 745)
               ----------------------------------
               11111111111111111111110100010110   (= -746) => ~745 = -746

 5. W1 << W2   W1 jest przesuwane w lewo o W2 krokow.

               5 << 4 => 101(b) << 4 = 1010000(b) = 80

 6. W1 >> W2  
               W1 jest przesuwane w prawo o W2 krokow.

               1054 >> 5 => 10000011110(b) >> 5 = 100000(b) = 32

Operatory warunkowe (logiczne)

 1. W1 || W2   Zwraca prawde jesli W1 lub W2 zwraca prawde. Nie obliczy
               W2 jesli W1 zwraca prawde.

 2. W1 && W2   Zwraca prawde, jesli zarowno W1 jak i W2 zwraca prawde.
               Nie wykona W2 jesli W1 zwraca falsz.

 3. !E         Zwraca prawde, jesli W jest falszywe i vice versa.

Operatory porównawcze

 1. W1 == W2   Zwraca prawde, jesli W1 jest rowne W2. Moze byc uzyty na
               wszystkich typach. Obejrzyj specjalny rozdzial o tablicach
               i mappingach, gdyz ten operator dziala na nich inaczej, niz
               by ci sie moglo wydawac.

 2. W1 != W2   Zwraca prawde jesli W1 jest rozne od W2. Moze byc uzyty
               na wszystkich typach. Obejrzyj specjalny rozdzial o 
               tablicach i mappingach, gdyz ten operator dziala na nich
               inaczej, niz by ci sie moglo wydawac.

 3. W1 > W2    Zwraca prawde, jesli W1 jest wieksze od W2. Moze byc uzyte
               na wszystkich typach poza tablicami i mappingami.

 4. W1 < W2    Zwraca prawde, jesli W1 jest mniejsze od W2. Moze byc uzyte
               na wszystkich typach z wyjatkiem tablic i mappingow.

 5. W1 >= W2   Zwraca prawde, jesli W1 jest wieksze lub rowne W2. Moze byc
               uzyte na wszystkich typach poza tablicami i mappingami.

 6. W1 <= W2   Zwraca prawde, jesli W1 jest mniejsze lub rowne W2. Moze byc
               uzyte na wszystkich typach z wyjatkiem tablic i mappingow.

Podwójne operatory przypisania

Wszystkie arytmetyczne i booleanowskie operatory mozna zapisac w prostszy sposob, o ile chcesz jedynie obliczyc dzialanie jednej zmiennej z jakims wyrazeniem, a wynik przechowac w tej zmiennej.

Powiedzmy, ze chcesz wykonac ‘a = a + 5;’. Lepiej mozna to zapisac tak: ‘a += 5;’. Wartosc drugiego wyrazenia jest dodawana do pierwszego i w nim przechowana (czyli w tym przypadku w zmiennej a).

Wszystkie inne operatory mozna zapisac w ten sam sposob, tj. napierw zmienna, potem ‘=’ poprzedzone operatorem, a na koncu wyrazenie.

    a >>= 5;       /* a = a >> 5; */
    b %= d + 4;    /* b = b % (d + 4); */
    c ^= 44 & q;   /* c = c ^ (44 & q); */

Priorytet operatorów i kolejność wykonywania działań

W ponizszej tabeli zawarte sa reguly dotyczace kolejnosci i laczenia wszystkich operatorow, wlaczajac w to te, o ktorych jeszcze nie bylo mowy. Operatory bedace w tej samej linii w tabeli maja taki sam priorytet, a operatory w kolejnych rzedach maja malejaca waznosc. Na przyklad ‘*’, ‘/’ i ‘%’ maja taki sam priorytet i jest on wyzszy od tego, ktory maja ‘+’ i ‘-’.

Zauwaz, ze priorytet logicznych operatorow bitowych ‘&’, ‘^’ i ‘|’ jest nizszy od priorytetu ‘==’ i ‘!=’. Powoduje to, ze wyrazenia testujace bity, takie jak

    if ((x & MASKA) == 0) ...

powinny byc cale ujete w nawiasy, zeby daly poprawne wyniki.

 1. () []                      Od lewej do prawej
 2. ! ~ ++ -- - (typ) * &      Od prawej to lewej

 3. * / %                      Od lewej do prawej

 4. + -                        Od lewej do prawej

 5. << >>                      L->P

 6. < <= > >=                  L->P

 7. == !=                      L->P

 8. &                          L->P

 9. ^                          L->P

10. |                          L->P

11. &&                         L->P

12. ||                         L->P

13. ?:                         L->P

14. = += == etc.               P->L

15. ,                          L->P

Instrukcje warunkowe

W LPC czesto korzysta sie z instrukcji warunkowych. Jest wiele metod ich zapisywania. Bardzo wazna rzecza jest to, ze w testach zero ‘0’ jest traktowane jako „falsz”, zas dowolna inna wartosc jako „prawda”. Oznacza to, iz puste tablice ‘({})’, puste stringi ‘""’ oraz puste mappingi ‘([])’ rowniez sa „prawda”, poniewaz nie sa ‘0’. Jesli chcesz poznac ich rozmiar, albo zbadac ich zawartosc, to musisz sie posluzyc specjalnymi funkcjami - o nich bedzie mowa pozniej.

Instrukcje if/else

‘if’ stanowi najczesciej spotykana instrukcje warunkowa. Jest latwa w uzyciu i moze byc laczona z instrukcja ‘else’ w razie potrzeby obsluzenia obu wynikow testu (tj. falszu i prawdy). Stosuje sie ja w taki sposob:

    if (wyrazenie) instrukcja;
    np.
        if (a == 5)
            a -= 4;

Jesli chcesz obsluzyc falszywy wynik testu (jest on wtedy, gdy wyrazenie w nawiasie zwrocilo falsz), to musisz dodac intrukcje ‘else’:

    if (wyrazenie) intrukcja_prawda else instrukcja_falsz;
    np.
        if (a == 5)
            a -= 4;
        else
            a += 18;

Jesli zmienna ‘a’ bedzie sie rownala 5, to od niej zostanie odjete 4, w przeciwnym wypadku, do zmiennej ‘a’ zostanie dodane 18.

Pamietaj, ze mozesz w miejsce instrukcji wstawic rowniez jakis blok.

Instrukcja switch

Jeslibys chcial przetestowac jedna zmienna na wiele roznych wartosci, to skonczyloby sie to na dosyc dlugiej liscie instrukcji ‘if-else-if-else’. Jednakze, jesli typ wartosci na ktore testujesz zmienna jest integerem, floatem lub stringiem to mozesz uzyc o wiele lepszej i bardziej skondensowanej metody testowania. Zalozmy, ze chcesz napisac nastepujacy kod:

    if (imie == "lewy")  // jesli imie == "lewy" to...
    {
        miasto = "lu";
        opis = "wesoly";
    }
    else if (imie == "alvin") // w przeciwnym wypadku, jesli imie == "alvin"
    {
        miasto = "wa";
        opis = "bursztynooki";
    }
    else if (imie == "athmagor") // jesli nie "alvin" i nie "lewy", to moze "athmagor"
    {
        miasto = "lu";
        opis = "piekny";
    }
    else
    {
        miasto = "x";
        opis = "nieznany";
    }

Lepszym sposobem na zapisanie tego jest:

    switch (imie)
    {
    case "lewy":
        miasto = "lu";
        opis = "wesoly";
        break;
    
    case "alvin":
        miasto = "wa";
        opis = "bursztynooki";
        break;
    
    case "athmagor":
        miasto = "lu";
        opis = "piekny";
        break;
    
    default:
        miasto = "x";
        opis = "nieznany";
    }

Ta instrukcja dziala bardzo prosto: ‘switch’ bierze wyrazenie spomiedzy nawiasow i porownuje je z kazdym z wyrazen wystepujacych po ‘case’.

UWAGA Wyrazanie po ‘case’ musi byc wartoscia stala. Nie moze to byc

zmienna, wywolanie funkcji, ani zadne inne wyrazenie tego typu.

Po tym, jak kompilator stwierdzi, ze wartosc w nawiasie rowna sie wartosci po ‘case’, wszystkie instrukcje wystepujace po ‘case’ zostana wykonane, az do momentu kiedy natrafi na instrukcje ‘break’. Jesli nie znajdzie zadnych rownajacych sie wartosci, wykonywane zostana instrukcje po ‘default’.

UWAGA! Nie ma przymusu pisania czesci ‘default’. Jest to jednak bardzo

polecane, gdyz wykonanie jej zazwyczaj oznacza, ze stalo sie cos, co nie bylo przewidziane w czasie pisania programu. Jesli uwazasz, ze testowana zmienna bedzie przyjmowala jakis ograniczony zestaw wartosci, to warto miec w zapleczu jakis komunikat bledu, ktory zostanie wyswietlony uzytkownikowi, gdy stanie sie cos nieoczekiwanego.

Gdy zapomnisz umiescic komendy ‘break’, kolejne wyrazenia ‘case’ beda wykonywane. Moze to nie brzmiec tak, jakbys chcial, ale na przyklad jesli powyzsze imiona ‘alvin’ i ‘lewy’ mialyby wygenerowac wspolne czynnosci, to moglbys napisac:

    case "lewy":
        /* nie ma break */
    case "alvin":
        < kod >
        break;

... i oszczedzic troche miejsa. Uzywanie switcha nie czyni kodu szybszym, jedynie zwieksza czytelnosc i zmniejsza ryzyko popelnienia jakiegos bledu w czasie pisania. Pamietaj umiescic jakis komentarz, w miejscu gdzie powinien byc break, gdyz potem mozesz zapomniec o tym, iz specjalnie go nie umiesciles. Dobrym pomyslem jest wstawianie jednej pustej linii po kazdym breaku, zeby dac ‘chwile oddechu’, co zwiekszy czytelnosc.

Wyrażenie ?:

Jest to bardzo skondensowana forma pisania instrukcji ‘if/else’ i zwracania roznych wartosci w zaleznosci od tego, jak wypadl test. Oczywiscie nie jest to instrukcja, lecz wyrazenie, poniewaz zwraca jakas wartosc. Nie mowilem o tym jak omawialem wyrazenia, bo bylo by mi ciezko to wytlumaczyc, przed wyjasnianiem instrukcji ‘if/else’.

Zalozmy, ze chcesz napisac cos takiego:

    if (testowane_wyrazenie)
        zmienna = wyrazenie_if;
    else
        zmienna = wyrazenie_else;

Mozesz to napisac w znacznie bardziej skondensowany sposob:

    zmienna = testowane_wyrazenie ? wyrazenie_if : wyrazenie_else;
    np.
        nazwa = dzien == 2 ? "wtorek" : "inny dzien";

Jest kwestia sporna, czy ten sposob zapisywania czyni kod bardziej, czy mniej czytelnym. Ale mysle, ze jedno wyrazenie tego typu ulatwia czytanie kodu, zas kombinacja kilku pogarsza tylko czytelnosc. Cos takiego, jak w nastepujacym przykladzie z pewnoscia nie jest ulepszeniem:

    nazwa = dzien == 2 ? godzina == 18 ? "czas na kwas" : "wtorek"
                       : "inny dzien";

Pętle

Petla to rodzaj instrukcji, ktora wykonuje okreslone czynnosci dopoki nie zostana spelnione pewne wczesniej zaprogramowane warunki. Sa dwa rodzaje petli i oba uzywaja instrukcji warunkowych.

Instrukcja while

Instrukcja while jest bardzo prosta w uzyciu. Juz z samej nazwy (while oznacza „dopoki”) mozna latwo wywnioskowac co ona robi. Bedzie ona caly czas wykonywala inna instrukcje, dopoki wyrazenie kontrolne nie zwroci falszu. Ma ona nastepujaca skladnie:

    while (<wyrazenie_kontrolne>) instrukcja_wykonywana;

Pamietaj, ze wyrazenie kontrolne jest sprawdzane na samym poczatku, jeszcze przed wywolaniem instrukcji po raz pierwszy. Jesli juz na samym poczatku wyrazenie kontrolne zwroci falsz, to instrukcja nigdy nie zostanie wykonana.

    a = 0;
    while (a != 4)
    {
        a += 5;
        a /= 2;
    }

Dopoki a ma wartosc rozna od 4, jest do niego dodawane 5, a potem jest dzielone przez 2. (Wiem, wiem, ten przyklad nie ma najmniejszego sensu :)).

Instrukcja for

Jesli potrzebujesz zwyklego licznika, to powinienes uzyc instrukcji ‘for’. Ma ona nastepujaca skladnie:

for (instrukcja_inicjalizujaca; wyrazenie_kontrolne; intrukcja_konca_cyklu)
    instrukcja_powtarzana;

Cala instrukcje mozna zapisac w inny rownowazny sposob, za pomoca instrukcji while:

 instrukcja_inicjalizujaca;
 while (wyrazenie_kontrolne)
 {
     instrukcja_powtarzana;
     intrukcja_konca_cyklu;
 }

Na samym poczatku, instrukcja ‘for’ wykonuje intrukcje_inicjalizujaca. Stosuje sie ja do poczatkowego ustawienia licznikow, lub innych wartosci uzywanych w czasie wykonywania petli. Od tego momentu trwa jej wlasciwa czesc. Kazdy cykl zaczyna sie od obliczenia „wyrazenia_kontrolnego” i sprawdzenia jego wyniku. Jesli jest prawdziwy, czyli wyrazenie zwroci od razu po niej instrukcja_konca_cyklu. W instrukcji_powtarzanej zawarte jest zazwyczaj to, co sie chce by petla cyklicznie wykonywala, a w instrukcji_konca_cyklu zazwyczaj zwieksza lub zmniejsza sie liczniki.

W poprzednim ustepie wiele razy uzylem slowa zazwyczaj. Zrobilem to dlatego, ze nie musisz robic tego w ten sposob; nie ma niczego co by cie przymuszalo do takiego wykorzystania tej instrukcji, jaki podalem.

Zalozmy, ze chcesz obliczyc sume wszystkich liczb calkowitych (integerow) z przedzialu od 7 do 123 i nie znasz na to wzoru ((x1^2 + x2^2) / 2). Najlatwiejsza (co nie oznacza najefektywniejsza) metoda, jest uzycie petli.

    wynik = 0;
    for (licznik = 7 ; licznik < 124 ; licznik++)
        wynik += licznik;

Na poczatku wynik jest zerowany. Po tym nastepuje wlasciwa czesc instrukcji ‘for’. Zaczyna sie od ustawienia zmiennej licznik na 7. Teraz nastepuje wejscie do petli i test, czy licznik (rowny 7) jest mniejszy niz 124. Jest tak, wiec wartosc licznika jest dodawana do zmiennej wynik. Zmienna licznik jest zwiekszana o jeden i nastepuje ponowne wejscie do petli. Dzieje sie tak, do momentu az wartosc licznika osiagnie 124. Poniewaz nie jest on wtedy mniejszy od 124, wykonywanie petli zostaje zakonczone.

UWAGA! Wartosc licznika po wykonaniu instrukcji ‘for’ jest rowna 124,

a nie 123, jak niektorzy ludzie sadza. wyrazenie_kontrolne musi zwrocic falsz, zeby petla mogla sie skonczyc i co za tym idzie licznik musi miec wartosc 124.

Instrukcje break i continue

Czasem, podczas wykonywania instrukcji ‘switch’, ‘for’ lub ‘while’ zachodzi potrzeba wyjscia z petli i kontynuacji poza nia. W tym celu uzywa sie instrukcji ‘break’.

    while (warunek_koncowy < 9999)
    {
        // Jesli funkcja time() zwroci 29449494, to przerwij wykonywanie
        // petli
        if (time() == 29449494)
            break;
    
        < kod >
    }
    
    // Kompilator wykonuje ten kod zarowno po uzyciu instrukcji `break',
    // jak i gdy petla sie skonczy.
    < kod >

Nieraz chcesz, by petla wykonala sie dodatkowo podczas uzycia instrukcji ‘for’ lub ‘while’. Do tego celu uzywa sie instrukcji ‘continue’.

    // Dodaje wszystkie parzyste liczby
    suma = 0;
    for (i = 0 ; i < 10000 ; i++)
    {
        // Zacznij petle od poczatku, gdy `i' zwraca nieparzysta liczbe
        if (i % 2)
             continue;
    
        suma += i;
    }

Kazde uzycie continue w tym przykladzie powoduje przeskoczenie jednego cyklu, gdyz licznik zostaje zwiekszony, ale zasadnicza czesc kodu pozostaje nie wykonana, bo instrukcja ‘continue’ znajduje sie przed nia.

Tablice i Mappingi

Nadszedl czas na zaglebienie sie w dwa specjalne typy: „tablice” i „mappingi”. Ich zastosowanie moze wygladac podobnie, lecz w rzeczywistosci bardzo sie od siebie roznia.

Dla obu typow napisano wiele uzytecznych efunkcji, ktore operuja i pobieraja z nich informacje. Jednakze zostana opisane one pozniej, a na razie przedstawie tylko kilka z nich.

Jak używać i deklarować tablice

Tablice w LPC to tak na prawde nie sa prawdziwe tablice. Lepiej okresla je to, ze sa to listy z okreslonym porzadkiem. Roznica moze sie wydawac niewielka, lecz dla informatykow jest ogromna.

Tablice maja okreslony typ, co oznacza, ze moga przyjmowac tylko takie elementy, u ktorych jest on zgodny z tablica. Innym ograniczeniem jest to, ze tablice moga byc tylko jednowymiarowe. Istnieje jednak mozliwosc obejscia tego, gdyz tablice z elementami typu mixed moga przyjmowac wartosci dowolnego typu, czyli nawet inne tablice. Powinienes jednak pamietac o ostroznym poslugiwaniu sie typami tablic, zeby nie popelnic jakiegos bledu.

Tablice definiuje sie w ten sposob:

    <typ> *<nazwa_tablicy>;
    np.
        int *moja_tab, *twoja_tab;
        float *inna_tab;
        object *tab_ob;

Poczatkowa wartoscia tych tablic jest ‘0’, a nie pusta tablica. Powtarzam: sa one ustawiane na zero – ‘0’, nie na pusta tablice – ‘({ })’. Pamietaj o tym!

Tablice alokuje i inicjalizuje sie w ten sposob:

    <tablica> = ({ elem1, elem2, elem3, ..., elemN });
    np.
        moja_tab = ({ 1, 383, 5, 391, -4, 6 });

Dostep do elementow tablicy mozna uzyskac dzieki podaniu numeru indeksu w nawiasach, po nazwie zmiennej zawierajacej tablice. (Zalozmy, ze zmienna wart jest zadeklarowana jako integer).

    <zmienna> = <tablica>[<indeks>];
    np.
        wart = moja_tab[3];

LPC, tak samo jak C, zaczyna liczenie od 0 i przez to czwarty element ma numer 3.

Zeby ustawic wartosc juz istniejacego elementu na nowa, uzywa sie operatora ‘=’.

        moja_tab[3] = 22;        // => ({ 1, 383, 5, 22, -4, 6 })
        moja_tab[3] = 391;       // => ({ 1, 383, 5, 391, -4, 6 })

W celu pobrania wycinka tablicy, wystarczy w nawiasach podac od ktorego, do ktorego elementu chce sie wyciac.

    <tablica> = <inna_tablica>[<odkad>..<dokad>];
    np.
        twoja_tab = moja_tab[1..3];

... spowoduje, ze nowa tablica ‘twoja_tab’ bedzie miala wartosc ‘({ 383, 5, 391 });’. Jesli starej tablicy przypisesz nowa wartosc, poprzednia zawartosc zostanie stracona.

np.

        moja_tab = ({ });

... spowoduje, ze ‘moja_tab’ stanie sie pusta tablica. Stara zostanie zdealokowana, a pamiec przez nia zajeta uwolniona.

Jesli podasz indeks, ktory wyjdzie poza rozmiar tablicy, to wyskoczy blad i wykonywanie obiektu zostanie przerwane. Jednakze, gdy indeks przy podawaniu zasiegu, np. indeks dokad wyjdzie poza tablice, to blad nie zostanie zakomuniukowany, zasieg zas zostanie tak ograniczony, by sie zmiescil w rozmiarze tablicy.

Jesli chcesz stworzyc pusta tablice, z wartosciami ustawionymi na 0 (typ nie gra roli) o okreslonej dlugosci, to mozesz uzyc efunkcji ‘allocate()’.

    <tablica> = allocate(<wielkosc>);
    np.
        twoja_tab = allocate(3);        // => twoja_tab = ({ 0, 0, 0 });

Dodawanie tablic do siebie daje sie latwo dokonac za pomoca operatora ‘+’. Wystarczy, ze zsumujesz je tak, jak sie sumuje liczby. Operator ‘+=’ rowniez do tego celu swietnie pasuje.

    moja_tab = ({ 9, 3 }) + ({ 5, 10, 3 }); // => ({ 9, 3, 5, 10, 3 })

Uzycie operatorow ‘-’ i ‘-=’ to najlatwiejszy sposob na usuwanie elementow z tablicy. Uwazaj jednakze, gdyz operator ten usunie wszystkie elementy, ktore beda mialy wartosc taka sama jak elementy, ktore chcesz usunac.

    moja_tab -= ({ 3, 10 }); // => ({ 9, 5 })

I jeszcze maly przyklad na wycinanie i doklejanie elementow tablic.

    moja_tab = ({ 9, 3, 5, 10, 3 });
    moja_tab = moja_tab[2..4] + moja_tab[0..0]; // => ({ 5, 10, 3, 9 })

        <tablica> moja_tab[0..0]   // = ({ 9 })
        <int>     moja_tab[0]      // = 9

UWAGA! Zwroc uwage na roznice!!! W piewszej linii jest tablica, a w drugiej integer!

Jak deklarować i uzywać Mappingi

Mapping to lista powiazanych par wartosci. Maja one wszystkie typ ‘mixed’. Oznacza to, ze czesc indeksowa pary nie musi miec przez caly czas tego samego typu. Jest to jednak bardzo doradzane, z powodu bledow jakie nieostrozne uzywanie typu ‘mixed’ moze spowodowac.

Zarowno indeks, jak i wartosc moze przyjmowac dowolny typ. Istnieje tylko jedno ograniczenie tyczace sie indeksow – nie moze byc dwoch indeksow o takiej samej wartosci w jednym mappingu.

Moze to troche pogmatwanie brzmiec z poczatku, ale tak na prawde to to jest bardzo banalne. Chyba latwiej zrozumiec bedzie jednak, jesli od razu przystapie do ilustrowania tego przykladami.

Mappingi deklaruje sie tak jak wszystkie inne zmienne. Zacznijmy wiec od kilku prostych deklaracji.

    mapping moj_map;
    int     wartosc;

Alokowac i inicjalizowac mozna na trzy rozne sposoby.

    1: <mapping> = ([ <indeks1>:<wartosc1>, <indeks2>:<wartosc2>, ... ]);
    
    2: <mapping>[<indeks>] = wartosc;
    
    3: <mapping> = mkmapping(<tablica indeksow>, <tablica wartosci>);

Pierwszy sposob jest prosty i naturalny.

    1: my_map = ([ "adam":5, "brunon":8, "czeslaw":-4 ]);

Dzialanie drugiego sposobu polega na tym, ze gdy nie istnieje w mappingu para o podanym indeksie – to jest tworzona, jesli istnieje – to wartosc pary jest zastepowana nowa.

    2: my_map["adam"] = 1;    // Tworzy pare "adam":1
       my_map["brunon"] = 8;  // Tworzy pare "brunon":8
       my_map["adam"] = 5;    // Zamienia stara wartosc w "adam" na 5.
       ...

Trzeci sposob wymaga dwoch tablic – jednej zawierajacej indeksy, a drugiej przechowujacej wartosci. Tworzenie tablic zostalo opisane w poprzednim rozdziale.

3: moj_map = mkmapping( ({ "adam", "brunon", "czeslaw" }), ({ 5, 8, -4 }) );

W przeciwienstwie do tablic, mappingi nie maja ustalonego porzadku. Wartosci sa poukladane w taki sposob, by maksymalnie skrocic czas ich wyszukania. Istnieja funkcje, ktore umozliwiaja pobranie listy elementow (indeksow, lub wartosci) z mappinga. Pamietaj tylko, ze moga one byc w dowolnej kolejnosci i nigdy nie ma pewnosci, ze beda tak samo ulozone pomiedzy dwoma wywolaniami funkcji „pobierajacych”. W praktyce jednak, kolejnosc jest zmieniana tylko w czasie dodawania lub usuwania elementow.

Mappingi laczy sie za pomoca operatorow ‘+’ i ‘+=’, zupelnie tak samo jak w przypadku tablic.

    moj_map += ([ "dobroslawa":5, "edmund":33 ]);

Usuwanie elementow z mappingu juz nie jest takie proste. Sluzy do tego specjalny efun ‘m_delete()’ (rowniez opisany dalej).

    moj_map = m_delete(moj_map, "brunon");
    moj_map = m_delete(moj_map, "dobroslawa");

Jak widzisz, elementy usuwa sie po kolei, podajac indeks jako identyfikator pary. Inna rzecza, ktora sobie musisz szybko uswiadomic jest to, ze indeksy musza byc unikalne, nie moze byc dwoch takich samych „uchwytow” do par. Jednakze wartosci oczywiscie moga byc takie same.

Poszczegolne wartosci mozna pobrac poprzez zwykle podanie indeksu.

    wartosc = moj_map["czeslaw"]; // => -4

Proba pobrania elementu o nieistniejacym indeksie nie wywola zadnego bledu, a jedynie zwroci 0. Musisz wiec byc bardzo ostrozny, gdyz 0 moze oznaczac rozne rzeczy, tzn. wartosc 0 moze oznaczac, ze element o podanym indeksie nie ma czesci z wartoscia, ale moze oznaczac tez, ze wartoscia jest 0.

    wartosc = moj_map["rgojhijaeh"]; // => 0

Preprocesor

Preprocesor nie jest czescia jezyka LPC. Jest to specjalny proces, ktory jest uruchamiany przed rozpoczeciem kompilacji. Mozna go postrzegac jako bardzo sprytnego „podstawiacza” stringow; Okreslone lancuchy znakowe sa zastepowane innymi.

Pierwszym znakiem kazdej dyrektywy preprocesora jest ‘#’. Poza tym musza sie one zaczynac w pierwszej kolumnie (na samym poczatku linii). Mozesz je umiescic gdziekolwiek w kodzie, acz jak sie dowiesz pozniej, wiekszosc z nich jest przypisana poczatkowi programu.

Instrukcja #include

Jest to najczesciej uzywana dyrektywa preprocesora. Mowi ona mu, aby zastapil linie w ktorej ona sie znajduje zawartoscia calego pliku, o nazwie podanej po instrukcji.

Dane, ktore umieszczasz we wlaczanyum pliku to takie, ktorych raczej nie bedziesz nigdy zmienial i takie, ktore bedziesz wlaczal w wiele plikow. Zamiast wpisywania tego samego tekstu w rozne pliki w nieskonczonosc i co za tym idzie zwiekszania szansy na jakies kretynskie bledy, po prostu zbierasz powtarzajace sie dane w jeden lub kilka plikow i wlaczasz(include) je w te programy, w ktore trzeba.

Skladnia jest bardzo prosta:

    #include <plik_standardowy>
    #include "plik_dodatkowy"

UWAGA! Zauwaz, ze nie ma ‘;’ na koncu linii!

Dwa rozne sposoby zapisywania nazw plikow zaleza od tego, gdzie sie one znajduja. Jest spora liczba standardowych bibliotek w grze, rozrzuconych po sporej liczbie katalogow. Zamiast zapamietywania dokladnie gdzie one sa, wystarczy ze podasz sama nazwe pliku, ktory chcesz wlaczyc.

    #include <stdproperties.h>
    #include <adverbs.h>

Gdy chcesz wlaczyc jakies pliki wlasne, ktore nie sa zadna standardowa biblioteka, to musisz dokladnie podac ich lokacje. Mozesz to zrobic zarowno poprzez podanie sciezki od katalogu, gdzie sie znajduje program, albo poprzez podanie pelnej, absolutnej sciezki od glownego katalogu.

    #include "/d/Standard/login/login.h"
    #include "moje_def.h"
    #include "/sys/adverbs.h"  // Ten sam, co krotszy przyklad powyzej

Gdy chcesz wlaczyc standardowe biblioteki, to zawsze uzywaj notacji < >. (czyli podawaj sama nazwe bilbioteki, ujeta w nawiasy < > ). Powodem nie jest tylko to, ze tak jest krocej, ale to, ze gdy biblioteki zostana przemieszczone gdzie indziej, twoj program przestanie dzialac. Gdy uzyjesz notacji <> to zawsze zostana znalezione.

Wlaczane pliki moga miec dowolna nazwe, ale ustalono, ze beda mialy koncowke ‘.h’, zeby moc je jasno odroznic od innych plikow.

Jest nawet mozliwe wlaczenie plikow ‘c’, tzn. calych plikow zawierajacych programy. Jednakze, jest to bardzo zla rzecz. Nie rob tego NIGDY! Czemu? Po pierwsze programy sledzace bledy gubia numeracje linii we wlaczanych plikach i przez to podaja zle numery linii. Po drugie, gdy wlaczasz nieskompilowany kod w wiele roznych obiektow, marnujesz pamiec oraz CPU, gdyz ten sam plik musi byc wielokrotnie kompilowany i przechowywany osobno, dla kazdego obiektu, ktory go uzywa. A poza tym samo czytanie takiego programu moze byc istna tortura.

Co ma wiec tak na prawde rozszerzenie nazwy pliku do jego zawartosci? Tak na prawde to nic nie ma... Jednakze jest przyjete, ze kod i funkcje sa przechowywane w plikach z rozszerzeniem ‘.c’, a definicje z rozszerzeniem ‘.h’. Mudlib zazwyczaj korzysta z tego rozdzialu i moze nie rozpoznawac jako kodu zrodlowego niczego, poza plikami z koncowka ‘c’.

Instrukcja #define

Jest to bardzo potezne „makro”, komenda preprocesora, ktora jest ciagle naduzywana. Madrze postapisz, jesli bedziesz uzywal jej ostroznie i tylko do prostych rzeczy.

Ma ona nastepujaca skladnie:

    #define <identyfikator> <tekst zastepujacy>
    #undef <identyfikator>

Dowolny taki sam tekst w pliku jak ‘<identyfikator>’ zostanie zastapiony ‘<tekstem zastepujacym>’, jeszcze przed kompilacja. ‘#define’ jest wazne od linii, w ktorej zostalo zdefiniowane do konca pliku, albo do momentu wykonania komendy ‘#undef’, ktora usuwa makro.

Pomimo tego, ze makrem moze byc dowolny tekst, jest w zwyczaju(rob tak!), ze nazwe makra pisze sie wylacznie duzymi literami. Jest to po to, zeby mozna bylo wyroznic makra w tekscie, w ktorym kazdy(ty tez!) pisze nazwy funkcji i zmiennych malymi literami.

Umieszczaj wszystkie definicje na poczatku pliku, albo biedny koles, ktory bedzie ci pomagal w wylapaniu bledow, bedzie mial prawdziwe piekielko z poszukiwaniem pochowanych definicji. Jesli to bedzie ktos, kogo sam poprosiles o pomoc (gdyz masz bledy powstale z powodu brzydko napisanego kodu), to najprawdopodobniej powie ci zebys sobie wsadzil taki program w wiadome miejsce i wrocil dopiero wtedy, jak sie nauczysz poprawnie i ladnie pisac.

Prostymi definicjami sa na przyklad sciezki, nazwy i wszystkie inne stale dowolnego rodzaju, ktorych nie chcesz w kolko zapisywac, albo chcesz miec mozliwosc latwej ich modyfikacji, bez zmieniania tego samego w dziesiatkach miejsc.

     MAX_LOGIN   100          /* Maksymalna liczba zalogowanych
                                        graczy */
     LOGIN_OB    "/std/login" /* Obiekt logowania        */
     POWIT_TEKST "Witamy!"    /* Komunikat logowania     */

Gdziekolwiek wystapi identyfikator makra, zostanie on zastapiony tym, co sie znajduje w definicji pomiedzy identyfikatorem, a koncem linii. Podchodza pod to takze komentarze, ktore jednak i tak zostana pozniej wyrzucone.

    tell_object(gracz, POWIT_TEKST + "\n");

Komentarz typu ‘//’ nie jest w takiej sutuacji dobra rzecza, gdyz konczy sie on dopiero na koncu linii.

     POWIT_TEKST    "Witamy!"    // Komunikat logowania

...bedzie zamienione w poprzednim przykladzie na:

    tell_object(gracz,    "Witamy!"    // Komunikat logowania + "\n");

...co spowoduje ujecie w komentarz wszystkiego, co wystapi po ‘//’, az do konca linii.

Gdy makro wychodzi poza linie, mozesz przedluzyc ja za pomoca znaku ‘\’ ktory zaznacza, ze definicja jest kontynuowana w nastepnej linii. Jednakze musisz zakonczyc linie tuz po ‘\’ i NIE nie moze byc za nim zadnych spacji, ani innych znakow.

     DLUGA_DEFINICJA  "poczatek stringa  \
                              i jego koniec."

Definicje nasladujace funkcje sa czesto stosowane i nieraz naduzywane. Jedyna na prawde wazna zasada, obowiazujaca przy pisaniu takich makr jest to, ze kazdy argument musi byc ujety w nawiasy. Jesli napiszesz inaczej, to mozesz otrzymac bardzo dziwne wyniki.

    1:  POMNOZ_TO(a, b) a * b        /* Zle */
    2:  POMNOZ_TO(a, b) (a * b)      /* Nie wystarczajaco */
    3:  POMNOZ_TO(a, b) ((a) * (b))  /* Wlasciwie */

Co za roznica pewnie zapytasz? Spojrz w takim razie na ten przyklad:

    wynik = POMNOZ_TO(2 + 3, 4 * 5) / 5;
    

Po podstawieniu wyglada to tak:

    1: wynik = 2 + 3 * 4 * 5 / 5;       // = 14, Zly
    2: wynik = (2 + 3 * 4 * 5) / 5      // = 12, Tez zly
    3: wynik = ((2 + 3) * (4 * 5)) / 5  // = 20, Wlasciwy!

Naduzycia definicji polegaja zazwyczaj na zlym ich ulozeniu i uzyciu skomplikowanych makr wewnatrz innych makr (co czyni kod prawie niemozliwym do zrozumienia). Podstawowa zasada jest pisanie krotkich i prostych makr. Rob tak, albo marny bedzie twoj koniec ;)

Instrukcje #if, #ifdef, #ifndef, #else i #elseif

Sa to dyrektywy preprocesora, ktore sluza selekcjonowaniu okreslonych czesci kodu i usuwaniu innych w zaleznosci od stanu zmiennych preprocesora.

Dzieki nim czesc kodu moze zostac uniewidoczniona dla kompilatora – cos jak inteligentne komentarze.

Instrukcja ‘#if’ jest bardzo podobna do zwyklej instrukcji if. Jest tylko troche inaczej zapisywana.

Zalozmy, ze mozesz miec gdzies nastepujaca definicje:

     CODE_VAR  2
    
    lub
    
     CODE_VAR  3

Wtedy mozesz napisac:

    #if CODE_VAR == 2
        <kod ten bedzie dopuszczony do kompilacji tylko jesli CODE_VAR == 2>
    #else
        <kod ten bedzie zachowany tylko wtedy gdy CODE_VAR != 2>
    #endif

Mozesz wogole nie pisac instrukcji ‘#else’ jesli tego nie chcesz.

Wystarczy napisac nastepujaca instrukcje, zeby zaistniala dana definicja preprocesora:

     CODE_VAR    /* Definiuje istnienie CODE_VAR */

I teraz mozesz napisac:

    #ifdef CODE_VAR
        <Kod, ktory bedzie zachowany tylko, jesli CODE_VAR istnieje>
    #else
        <kod, ktory bedzie zachowany tylko wtedy, gdy CODE_VAR nie jest
         zdefiniowane>
    #endif

lub

    #ifndef CODE_VAR
       <kod, ktory bedzie zachowany tylko wtedy, gdy CODE_VAR *nie* jest
        zdefiniowane>
    #else
       <kod, ktory bedzie zachowany, jesli CODE_VAR istnieje>
    #endif

I ponownie, instrukcje ‘#else’ mozna sie ominac.

Komendy preprocesora ‘#if/#ifdef/#ifndef’ sa prawie wylacznie uzywane do dodania odpluskwiajacego kodu, ktory nie powinien byc caly czas aktywny lub do pisania rzeczy, ktore beda roznie pracowaly w zaleznosci od bardzo rzadko zmieniajacych sie parametrow.

Cala konfiguracja mudliba jest sprawdzana w ten sposob. Na przyklad jest definicja MET_ACTIVE, ktora sluzy ustalaniu czy system met/nonmet (nie kazdy zna kazdego gracza) ma byc wlaczony czy nie. Gdy administrator muda zdecyduje sie na wylaczenie tego, wystarczy ze w jednym pliku konfiguracyjnym zamieni ‘#define MET_ACTIVE’ na ‘#undef MET_ACTIVE’. (W Arkadii wiele takich definicji znajdziesz w ‘/config/sys/local.h’).

Podstawy Mudliba i LPC

W rozdziale tym nauczysz sie wszystkiego, czego potrzebujesz by pisac kod w srodowisku gry. Bede unikal bardziej skomplikowanych tematow, pozostawiajac ich omowienie na trzeci rozdzial. Dowiesz sie tu wielu rzeczy na temat mudliba i pracy gamedrivera – wiedzy niezbednej do pisania dzialajacego i efektywnego kodu.

Małe wybiegnięcie w przyszłość

Aby moc pokazac ci przyklady tego, czego bede cie probowal nauczyc, musze ci wpierw z wyprzedzeniem wyjasnic kilka funkcji. Bedzie to powtorzone w odpowiednim kontekscie pozniej. Tutaj jest zamieszczony jedynie krotki przeglad, zebys wiedzial co robie.

Zeby pokazac pokazac jakis tekst na ekranie gracza, uzywa sie efunkcji ‘write()’. Istnieja dwa specjalne znaki, ktore sa dosc czesto uzywane do formatowania tekstu. Sa to: znak „tabulacji” i znak „nowej linii”. Zapisuje je sie w ten sposob: (kolejno) ‘\t’ i ‘\n’. Znak „tabulacji” wstawia osiem spacji, a znak „nowej linii”, jak sama nazwa wskazuje lamie linie, czyli konczy stara i przechodzi do nowej.

    void write(string tekst)
    np.
        write("Siemanko!\n");
        write("\tTo jest wciety string.\n");
        write("Ten string\njest rozlozony na kilka linii\n\ti czesciowo" +
               "\nwciety.\n");
    
        /* Wynikiem bedzie:
    
           Siemanko!
                   To jest wciety string.
           Ten string
           jest rozlozony na kilka linii
                   i czesciowo
           wciety.
         */

Jesli masz tablice, mapping albo zwykla zmienna dowolnego typu i chcesz wyswietlic to na ekranie, np. zeby pomoc sobie w wyszukiwaniu bledow, to sfunkcja ‘dump_array()’ moze sie okazac bardzo pomocna. Podajesz zmienna, ktora chcesz wyswietlic jako argument i jej zawartosc zostanie ukazana na ekranie.

    void dump_array(mixed dane)
    np.
        string *imie = ({ "franek", "zdzichu", "bolo" });
        dump_array(imie);
    
        /* Wynikiem bedzie
    
           (Array)
           [0] = (string) "franek"
           [1] = (string) "zdzichu"
           [2] = (string) "bolo"
         */

Drugi rzut oka na LPC

Wytlumacze ci teraz pominiete w poprzednim rozdziale informacje o LPC. Ta wiedza jest ci potrzebna do tworzenia dzialajacych obiektow w srodowisku gry.

Wywołania funkcji

Sa dwa rodzaje wywolan funkcji: wewnetrzne i zewnetrzne. Jedynym rodzajem o jakim dotad mowilismy byly wywolania wewnetrzne, choc zewnetrzne tez sie znalazly w kilku miejscach.

Tworzenie wewnątrzobiektowych wywołań funkcji

 [call_self]

Robienie wewnetrznych wywolan funkcji jest tak proste, jak pisanie nazwy funkcji i argumentow w nawiasach po niej. Lista argumentow jest albo lista wyrazen, albo wogole jej nie ma. Wywolanie funkcji jest oczywiscie wyrazeniem rowniez.

    <funkcja>(<lista argumentow>);
    np.
        zmienna = jakas_funkcja(1.0) * 4;

Jest inny sposob na zrobienie tego. Jesli nazwe funkcji masz przechowana w jakiejs zmiennej i chcesz ja wywolac, to pomocna moze sie okazac funkcja ‘call_self()’:

    call_self(<"nazwa funkcji">, <lista argumentow>);
    np.
        zmienna = call_self("jakas_funkcja", 1.0) * 4;

Jesli uzywajac ‘call_self()’ podasz nazwe nieistniejacej funkcji, wyskoczy blad i wykonywanie obiektu zostanie przerwane.

Tworzenie prostych zewnątrzobiektowych wywołań funkcji

 [call_other]

Wywolanie zewnetrzne, to wywolanie funkcji z innego obiektu. Zeby moc to zrobic, potrzebujesz odnosnika do obiektu w ktorym chcesz ja wywolywac. Nie mowilismy jeszcze o tym, jak zdobyc odnosnik do obiektu, ale zalozmy ze juz go masz.

mixed <odnosnik do obiektu/sciezka do obiektu>-><funkcja>(<lista argumentow>);
mixed call_other(<odn ob/sciezka ob>, "<funkcja>", <lista argumentow>);

np.

        /*
         * Zalozmy, ze chce wywolac funckje 'oblicz_cos' w obiekcie
         * "/d/Mojadomena/wiz/obiekt" i ze mam jakis wlasciwy wskaznik
         * obiektu przechowany w zmiennej 'obiekcik'
         */
        zmienna = obiekcik->oblicz_cos(1.0);
        zmienna = "/d/Mojadomena/wiz/obiekt"->oblicz_cos(1.0);
        zmienna = call_other(obiekcik, "oblicz_cos", 1.0);
        zmienna = call_other("/d/Mojadomena/wiz/obiekt", "oblicz_cos", 1.0);
        /*
         * Te cztery linijki robia dokladnie to samo
         */

Jak widzisz, efunkcja ‘call_other()’ dziala analogicznie do ‘call_self()’.

Kiedy zewnetrznie wywolujesz funkcje poslugujac sie sciezka do obiektu, tak zwany „master object” zostaja wywolany. Jesli obiekt, w ktorym wywolujesz nie zostal jeszcze zaladowany do pamieci, to zostanie. Gdy sprobujesz wywolac nieistniejaca funkcje, zostanie zwrocone 0 bez zadnych komunikatow bledu. Jesli wywolasz funkcje z obiektu, ktory ma jakies bledy, to zostanie wyswietlony komunikat bledu i dzialanie obiektu ktory wykonal wywolanie zostanie przerwane.

Po co wiec ten ‘call_self()’ w takim razie? Przeciez moznaby uzywac zamiast niego ‘call_other()’ przez caly czas z takim samym skutkiem? Nie do konca tak. ‘call_other()’ miesza jeszcze sporo w czyms co sie nazywa dostepem do funkcji w obiekcie – o tym jeszcze nie mowilem. Roznica polega na tym, ze ‘call_self’ rzeczywiscie dziala jak jakiekolwiek wywolanie wewnetrzne (ma dostep do wszystkich funkcji w danym obiekcie), podczas gdy ‘call_other()’ jest typowym wywolaniem zewnetrznym. Pamietaj o tym, kiedy bede omawial roznice pomiedzy dostepem w wywolaniach wewnetrznych i zewnetrznych.

Tworzenie wielokrotnych zewnątrzobiektowych wywołań funkcji

Mozesz wywolywac wiele obiektow na raz, tak samo prosto jakbys to robil z jednym. Jesli masz tablice stringow ze sciezkami, albo wskaznikow do obiektow lub mapping, w ktorym wartosci sa sciezkami do plikow lub wskaznikami do obiektow, to mozesz w jednej instrukcji wywolac je wszystkie. Rezultatem bedzie albo tablica z wynikami, jesli wywolywales za pomoca tablicy, albo mapping z takimi samymi indeksami z jakimi wywolywales, jesli korzystales z mappinga.

    (tablica/mapping)    <tablica/mapping>-><funkcja>(<lista argumentow>);
    np.
        /*
         * Potrzebuje mappingu, gdzie indeksami beda imiona graczy, a
         * wartosciami ich hitpointy.
         */
        object *ludzie;
        mapping hp_map;
        string *imiona;
    
        // Przypisuje liste wszystkich graczy.
        ludzie = users();
    
        // Bierze ich imiona.
        imiona = ludzie->query_real_name();
    
        // Tworzy mapping, przy pomocy ktorego beda robione wywolania.
        // Element = imie:wskaznik
        hp_map = mkmapping(imiona, ludzie)
    
        // Zastepuje wskazniki wartosciami hitpoint.
        hp_map = hp_map->query_hp();
    
        // A wszystko to mogloby byc zrobione prosciej w ten sposob:
        hp_map = mkmapping(users()->query_real_name(), users()->query_hp());

Dziedziczenie obiektów

Zalozmy, ze chcesz zakodowac jakas rzecz, drzwi na przyklad. Musisz wiec zaprogramowac mozliwosc otwierania i zamykania przejscia pomiedzy dwoma pokojami. Byc moze chcesz rowniez moc otwierac i zamykac zamek w drzwiach. O wszystko to musisz zadbac w swoim kodzie. Na dodatek, bedziesz musial kopiowac ten sam kod za kazdym razem, kiedy dodasz nowe drzwi i bedziesz chcial zeby roznily sie tylko opisem.

Po jakims czasie wkurzysz sie na to wszystko, czesciowo dlatego, ze odkryjesz ze inni wizardzi napisali wlasne drzwi, ktore dzialaja prawie - lecz nie do konca – tak jak twoje, przez co twoje swietne obiekty beda bezuzyteczne poza twoja domena.

Myslenie zorientowane obiektowe polega na tym, ze zamiast powtarzac takie pisanie w kolko, tworzy sie podstawowy obiekt drzwi, ktory moze robic wszystko to, co uwazasz, ze typowe drzwi powinny moc. Wtedy dziedziczy sie go w naszych konkretnych drzwiach, konfiguruje sie je (nie obiekt dziedziczony), korzystajac z mozliwosci drzwi „rodzica”.

Jest nawet mozliwe dziedziczenie kilku obiektow, choc „wielokrotne dziedziczenie” niesie ze soba kilka trudnych problemow do rozwiazania, wiec staraj sie unikac tego.

Skladnia na dziedziczenie obiektow jest bardzo prosta. Na poczatku pliku pisze sie cos takiego:

    inherit "<sciezka do pliku>";
    np.
       inherit "/std/door"; // (door oznacza drzwi)
       inherit "/std/room.c";

UWAGA! To NIE jest dyrektywa preprocesora, a zwykla instrukcja, wiec stawia sie ‘;’ na koncu i NIE pisze sie ‘#’ przed nia. Jesli chcesz, mozesz wyszczegolnic w sciezce, ze chodzi o plik c, aczkolwiek to nie jest konieczne.

„Dziecko” dziedziczy wszystkie funkcje i wszystkie zmienne, ktore sa zadeklarowane w sposob pozwalajacy na ich dziedziczenie. Jesli masz funkcje o takiej samej nazwie jak w obiekcie „rodzicu”, to twoja „zamaskuje” funkcje „rodzica”. Kiedy funkcja bedzie wolana poprzez wywolanie zewnetrzne, to wykonana zostanie twoja funkcja. Wewnetrzne wywolania w „rodzicu” beda sie jednak odnosily do jego funkcji. Nieraz potrzebujesz wywolac funkcje „rodzica” z „dziecka” – robi sie to poprzez dodanie ‘::’ przed wewnetrznym wywolaniem funkcji.

    void
    moja_funkcja()
    {
        /*
         * Ta funkcja istnieje i w naszym obiekcie(dziecku) i w obiekcie
         * ktory dziedziczymy(rodzicu), ale potrzebujemy ja
         * wywolac z rodzica.
         */
        ::moja_funkcja();        // Wywoluje moja_funkcje w rodzicu.
    }

Nie da sie wywolac zamaskowanej funkcji w rodzicu poprzez wywolanie zewnetrzne, mozliwe jest to tylko z rodzica. Gdy obiekt dziedziczy inny, ktory z kolei dziedziczy jeszcze inny, np. C dziedziczy B, a ten dziedziczy A, to wtedy maskowana funkcja z A, jest mozliwa do wywolania tylko w B, a w C juz nie.

Cienie : Maskowanie funkcji w czasie wykonywania obiektu

Jest cos takiego w LPC, co jest zwane „cieniowaniem”. Purytanie wola jednak nazywac to „obrzydlistwem” i przy kazdej okazji krzycza zeby to usunac, gdyz wystepuje to prawie przeciwko wszystkiemu, czego uczy sie o dobrym programowaniu. „Cieniowanie” jest raczej uzyteczne w grze, aczkolwiek moze spowodowac troche problemow glownie zwiazanych z bezpieczenstwem. Uzywaj tego z rozwaga!

Gdy jeden obiekt cieniuje drugi, wszystkie powtarzajace sie funkcje i zmienne z cieniujacego obiektu, zamaskuja te z cieniowanego obiektu. Wywolania cieniowanych funkcji, spowoduja wykonanie zamiast nich, tych z cieni. Cien praktycznie ‘stanie’ sie obiektem, ktory cieniuje. Od zwyklego maskowania rozni je to, ze funkcje sa maskowane w czasie kompilacji. Obiekty-cienie zas sa dodawane do obiektow juz w czasie ich dzialania. Mozna w ten sposob dodac do obiektu jakies wlasciwosci, ktore nie sa przewidziane w kodzie.

To wszystko na razie na ten temat. Sposob tworzenia i zastosowanie cieni beda szczegolowo omowione pozniej. Jak na razie wiesz wszystko, co potrzebujesz wiedziec.

Identyfikacja typów

 [intp, floatp, functionp, stringp, objectp, mappingp, pointerp]

Ze wzgledu na fakt, ze wszystkie zmienne sa na poczatku ustawiane na 0 i ze wiele funkcji zwraca 0 w razie bledu, warto moc zbadac jaki typ wartosci odebralismy. Rowniez, gdy uzywa sie typu ‘mixed’, niezbedna jest informacja jaki typ wartosci zawiera zmienna. Do tego celu istnieja specjalne funkcje kontrolne, ktore zwracaja 1 (prawde) jesli testowane wartosci sa danego typu, a 0 jesli nie.

int intp(mixed)

    Sprawdza, czy podana wartosc jest typu integer

int floatp(mixed)

    Sprawdza, czy podana wartosc jest typu float

functionp(mixed)

    Sprawdza, czy podana wartosc jest wskaznikiem funkcji (typ function)

int stringp(mixed)

    Sprawdza, czy podana wartosc jest stringiem

int objectp(mixed)

    Sprawdza, czy podana wartosc jest wskaznikiem obiektu (typ object)

int mappingp(mixed)

    Sprawdza, czy podana wartosc jest mappingiem

int pointerp(mixed)

    Sprawdza, czy podana wartosc jest tablica

UWAGA! Funkcje te sprawdzaja typ wartosci, a NIE sama wartosc

w znaczeniu poprawnosci dzialania. Innymi slowy ‘intp(0)’ zawsze zwroci prawde, tak jak to zrobi ‘mappingp(([]))’.

Kwalifikatory typów

Typy, ktore przypisujesz zmienym i funkcjom moga miec rozne kwalifikatory, zmieniajace sposob ich dzialania. Bardzo wazne jest to, by o nich caly czas pamietac i uzywac w odpowiednich miejscach. Wiekszosc z nich inaczej dziala na zmiennych, a inaczej na funkcjach, wiec male klopoty zwiazane z ich uzywaniem sa dosyc powszechne wsrod programistow. Postaraj sie przejsc przez to teraz, a nie bedziesz mial pozniej zadnych problemow.

Kwalifikator zmiennej ‘static’

Jest to dosyc klopotliwy kwalifikator, gdyz dziala on inaczej nawet na rozne zmienne, w zaleznosci od tego gdzie one sa! Zmienne globalne (jak na pewno wiesz) definiowane sa na poczatku pliku, na zewnatrz funkcji. Sa one dostepne we wszystkich funkcjach, tzn. ich „zasieg” rozciaga sie na caly obiekt i nie jest ograniczony do jednej funkcji.

Istnieje mozliwosc nagrania wszystkich zmiennych globalnych jakiegos obiektu, za pomoca pewnej efunkcji (opisana bedzie dalej). Jednakze, jesli zmienna globalna jest zdefiniowana jako ‘static’, to nie bedzie nagrana.

    static string   JakasNazwa;        // Nie nagrywana zmienna globalna.

Kwalifikator funkcji ‘static’

Do funkcji, ktore sa zadeklarowane z uzyciem kwalifikatora ‘static’ nie mozna stosowac zewnetrznych wywolywan, tylko wewnetrzne. Czyni to taka funkcje ‘niewidzialna’ i niedostepna dla innych obiektow. Miedzy innymi tu jest wlasnie ta roznica pomiedzy wewnetrznymi a zewnetrznymi wywolaniami funkcji, o ktorej wczesniej mowilem.

Kwalifikator funkcji/zmiennej ‘private’

Zmienne lub funkcje, ktore zostaly zadeklarowana jako ‘private’ nie beda mogly byc dziedziczone przez inne obiekty. Dostep do nich ma tylko obiekt, ktory je definiuje.

Kwalifikator funkcji/zmiennej ‘nomask’

Funkcje i zmienne, ktore sa zadeklarowane jako ‘nomask’ nie moga byc maskowane w zaden sposob, ani przez cieniowanie, ani przez dziedziczenie. Jesli sprobujesz zamaskowac takowa, to otrzymasz komunikat bledu.

Kwalifikator funkcji/zmiennej ‘public’

Jest to standardowy kwalifikator dla wszystkich funkcji i zmiennych. Oznacza to, ze nie narzuca on zadnych innych ograniczen ponad te, ktore sa narzucone przez jezyk.

Kwalifikator funkcji ‘varargs’

Funkcje, ktore sa zdefiniowane jako ‘varargs’ beda mogly otrzymywac rozna liczbe argumentow. W takim przypadku nie ma potrzeby podawania ich wszystkich przy wywolywaniu, zeby bylo ono prawidlowe. Moga byc ustalone standardowe wartosci dla argumentow, ktore nie otrzymaly zadnych wartosci.

    varargs void
    mojafun(int a, string str = "pelle", float c = 3.0);
    {
    }

Jak widzisz, kilka argumentow dostalo standardowe wartosci, ktore beda uzyte w przypadku gdy dany argument nie zostanie podany. Jesli nie ustalisz standardowej wartosci, to wartosc nie podanego argumentu zostanie ustawiona na 0.

Drugi rzut oka na typy danych

Jeden typ danych byl dotad mniej lub bardziej ignorowany. Jest nim typ ‘function’. Jako, ze obiekty maja swoj wlasny typ, funkcje maja taki rowniez. Dzieki niemu mozesz miec zmienne, poprzez ktore bedziesz mogl wywolywac funkcje. Przewaznie jest on jest uzywany w polaczeniu z innymi funkcjami, ktore uzywaja go jako parametru.

Zmienna tego typu definiuje sie tak jak kazda inna:

    <typ danych> <nazwa zmiennej>, <inna zmienna>, ..., <ost. zmienna>;
    np.
        function moja_fun, *tablica_fun;

Przypisywanie odnosnikow funkcji do nich nie jest jednak takie proste. Mozesz przypisac dowolny typ funkcji do zmiennej tego typu: czy efunkcja, czy sfunkcja, czy lfunkcja nie czyni zadnej roznicy. Istnieje nawet mozliwosc przypisania odwolania do funkcji zewnetrznej.

Przypisanie wskaznika do funkcji wymaga tego, by dana funkcja byla zdefiniowana, albo poprzez prototyp, albo poprzez deklaracje. Zalozmy, ze jak na razie interesuja cie tylko proste wskazniki do funkcji.

    <zmienna typu `function'> = <nazwa funkcji>;
    <zmienna typu `function'> = &<nazwa funkcji>();
    np.
        moja_fun = allocate;
        moja_fun = &allocate();

Wskaznika do funkcji uzywa sie tak samo jak zwyklego wywolania funkcji.

    int *i_tabl;
    

    i_tabl = allocate(5);   // Korzystamy z powyzszego 
    i_tabl = moja_fun(5);   // ... przypisania wskaznika funkcji.

Wystarczy tego na teraz. Pozniej wyjasnie jak tworzyc bardziej skomplikowane struktury funkcji.

Drugi rzut oka na instrukcję switch/case

Instrukcja switch jest bardzo sprytna i mozna w niej stosowac testowac, czy jakas wartosc typu integer miesci sie w podanym zakresie:

    public void
    kolo_fortuny()
    {
        int i;
    
        i = random(10);     // Przypisuje losowa liczbe z zakresu 0-9
    
        switch (i)
        {
        case 0..4:
            write("Sprobuj jeszcze raz, frajerze!\n");
            break;
    
        case 5..6:
            write("Ekstra, masz trzecie miejsce!\n");
            break;
    
        case 7..8:
            write("Tak! Drugie miejsce!\n");
            break;
    
        case 9:
            write("OOPS! Udalo ci sie!\n");
            break;
    
        default:
            write("Ktos grzebal przy kole... Wykrec 997!\n");
            break;
        }
    }

catch/throw: Obsługa blędów w czasie działania programu

Czasami zachodzi potrzeba wywolania funkcji, o ktorej wiadomo, ze moze zwrocic blad runtime (czyli taki, ktory wynikl po kompilacji, juz w czasie dzialania programu). Na przyklad w swoim programie mozesz chciec sklonowac jakis obiekt (opisane pozniej) albo zaladowac plik. Jesli nie ma takiego pliku, lub gdy masz niewystarczajace przywileje, to wyskoczy blad runtime i wykonanie programu zostanie zatrzymane. W tych okolicznosciach przydalaby sie mozliwosc przechwycenia bladu i wyswietlenia wlasnego komunikatu o bledzie, lub tez wykonania innej czynnosci. Jest to mozliwe dzieki funkcji ‘catch()’. Jako argument podaje sie w niej zmienna typu ‘function’. Jesli ‘catch()’ zwroci 1 (prawde), to bedzie to oznaczalo, ze wystapil blad w czasie wykonywania podanej funkcji. Jesli wszystko z podana funkcja bedzie ok, to zwroci 0.

    int catch(function)
    np.
        if (catch(tail("/d/Relikwa/fatty/tajna_mapa_do_ukrytych_orzeszkow")))
        {
            write("Przykro mi, nie ma mozliwosci przeczytania tego "+
                  "pliku.\n");
            return;
        }

Jest takze mozliwe wywolanie bledu i co za tym idze przerwanie programu. Jest to uzyteczne, gdy chcesz powiadomic uzytkownika o nieplanowanym zdazeniu, ktore wystapilo w czasie dzialania programu. Zazwyczaj sie to umieszcza w czesci ‘default’ komendy switch, o ile (oczywiscie) nie uzywasz tej czesci jako pewnego rodzaju lapacza wszelkich pozostalych mozliwosci.

    throw(mixed info)
    np.
        if (test < 5)
            throw("BLAD: Zmienna 'test' ma wartosc mniejsza niz 5.\n");

Wskaźniki do tablic i Mappingów

W terminologii informatycznej tablice i mappingi sa uzywane jako "odniesienie poprzez wskaznik", podczas gdy inne zmienne jako "odniesienie poprzez wartosc". Oznacza to, ze tablice i mappingi, w przeciwienstwie do innnych rodzajow zmiennych w czasie kopiowania nie sa dublowane. Zamiast nich, dublowany jest tylko wskaznik do oryginalnej tablicy czy mappinga. Co to wszystko oznacza?

Hmm... Po prostu to:

    object *tab, *tab_2;
    
    tab = ({ 1, 2, 3, 4 });    // Jakas tablica.
    
    tab_2 = tab;               // Zalozmy (zle), ze 'tab_2' 
                               // staje sie kopia tablicy 'tab'.
    
    // Zmieniamy pierwszy element (1) na 5.
    tab_2[0] = 5;

... I teraz ... logicznie rzecz biorac wydawaloby sie, ze wartosc pierwszego elementu tab_2 rowna jest 5, podczas gdy ten sam element w ‘tab’ wynosi 1. Nie jest tak jednak, gdyz to co zostalo skopiowane do zmiennej tab_2 nie bylo tablica, tylko wskaznikiem do tej samej tablicy co ‘tab’. Oznacza to, ze nasze dzialanie zmienilo pierwszy element w oryginalnej tablicy, do ktorej obie zmienne maja wskazniki. Wydawalo by sie, ze ‘tab_2’ i ‘tab’ obie sie zmienily, podczas gdy w rzeczywistosci zmianie ulegla tylko tablica, do ktorej obie zmienne sie odwolywaly.

Dokladnie to samo sie stanie w przypadku mappingow, gdyz pod tym wzgledem dzialaja one tak samo.

Wiec.. jak w takim razie obejsc to? Czasem na prawde zachodzi potrzeba pracy na kopii, a nie na oryginale tablicy czy mappingu. Rozwiazanie jest bardzo proste. Trzeba sie tylko upewnic, ze kopia zostala stworzona z innej tablicy lub mappingu.

                _ To jest po prostu pusta tablica.
               /
    tab_2 = ({ }) + tab;
                       \_ A to jest ta szczegolna, o ktora nam chodzi.

W tym przykladzie ‘tab_2’ staje sie suma tablicy pustej i tablicy `tab', stworzona jako zupelnie nowa tablica. Pozostawi to w przyszlosci oryginal bez zmian, dokladnie tak jak chcielismy. Mozesz uczynic dokladnie to samo z mappingami. Nie gra roli to, czy pusta tablice lub mapping dodajesz z przodu, czy z tylu, o ile wogole dodajesz.

Interfejs LPC/Mudliba

Jest sporo rzeczy, ktore mozesz zechciec zrobic, ktorych nie da sie wyrazic tylko za pomoca elementow jezyka LPC. Jest to na przyklad obsluga lancuchow znakowych czy tez zapisywanie do plikow. Rzeczy te sa bowiem czescia ‘standardowego zestawu funkcji’, ktory zawiera wiekszosc jezykow programowania. Ten rozdzial ma nauczyc cie podstaw robienia wszystkich tego typu rzeczy, potrzebnych do tworzenia obiektow LPC.

Istnieje okreslony zestaw globalnych wlasciwosci, co do ktorych mozesz miec pewnosc, ze beda dostepne zawsze w dowolnym obiekcie. Oto one:

• creator

Kazdy obiekt jest tworzony przez kogos. Tozsamosc autora zalezy od lokacji zrodla (pliku zrodlowego, czyli takiego, z ktorego obiekt jest wykonywany) w systemie plikow. Jesli obiekt znajduje sie w katalogu zwyklego czarodzieja, wtedy jako jego autora podaje sie imie tego czarodzieja. W innym przypadku podawana jest nazwa domeny. Dla obiektow mudliba, autorem jest ‘root’ w przypadku obiektow o prawach administratora, albo ‘backbone’ w przypadku reszty.

• uid/euid

"uid" (User ID – czyli identyfikator uzytkownika) obiektu okresla najwyzszy mozliwy poziom przywilejow dla danego obiektu. Samo uid jest uzywane tylko do ograniczania na "euid" (Effective User ID – czyli rzeczywisty identyfikator uztykownika) tego samego lub innego obiektu. Euid jest uzywane w sytuacjach, gdy przywileje obiektu musza byc sprawdzone, np. dostep do pliku (czytanie/zapisywanie/usuwanie), badz tworzenie obiektu.

• living

Zeby obiekt mogl przyjmowac badz wydawac komendy, musi byc livingiem.

Definicja obiektów standardowych i bibliotecznych

Jak juz poprzednio mowilem, gamedriver prawie nic nie wie o grze. A conajwyzej tak malo, jak to mozliwe. To mudlib musi sie tym wszystkim zaopiekowac. Zajmiemy sie teraz podstawowymi sprawami z nim zwiazanymi, np. poruszaniem sie, poziomami oswietlenia, tym jak obiekty powinny sie kontaktowac z graczami, itp. Po tym stworzymy obiekty, ktore beda wykorzystywaly omowione funkcje.

Zwykly czarodziej nie musi przesiadywac dlugich godzin zastanawiajac sie jak napisac obiekt, bedacy w prawidlowej relacji z innymi i rozpatrujac jeszcze tysiace innych, klopotliwych spraw. Zamiast tego dziedziczy odpowiadajacy mu, jeden ze standardowych obiektow. Pozniej tylko dorzuca don kilka ustawien, czyniac go unikalnym wzgledem innych obiektow tego typu.

Konsekwencja tego jest sytuacja w ktorej wszystkie obiekty w grze w 100% polegaja na fakcie, ze okreslone typy obiektow (pokoj, potwor, bron) maja okreslone zestawy powszechnych cech i mozliwosci. Po prostu musza miec, by mogly wspolpracowac w ustalony sposob. Jesliby nie mogly, jesliby kazdy czlowiek mial inne rozwiazanie tego samego problemu, obiekty dzialalyby tylko na terenie danego czarodzieja i nigdzie poza nim. Nie byloby mozliwe uzywanie miecza w calej grze. Ba! Nawet nie moznaby go nigdzie przemiescic. Oczywiscie oznacza to, ze musimy wymuszac jednomyslnosc, gdyz niemozliwe jest stworzenie (i uzytkowanie) obiektow, ktore nie dziedzicza tych specjalnych obiektow. Jak sam pozniej zobaczysz mozliwym byloby napisanie miecza, ktory nie bedzie dziedziczyc standardowego obiektu broni, tyle ze wtedy dzierzenie go staloby sie bariera nie do przebycia...

Istnieja rozne standardowe obiekty uzywane do roznych celow, ale najwazniejszym z nich jest ‘/std/object.c’.

Podstawowy obiekt: /std/object.c

Ten obiekt jest wielozadaniowy. WSZYSTKIE obiekty majace ‘fizyczna’ postac dziedzicza go. Dziedziczac jeden ze standardowych obiektow mozesz byc pewien, ze posrednio dziedziczysz takze ‘object.c’, gdyz jest on dziedziczony przez przewazna wiekszosc standardowych obiektow.

Standardowy obiekt definiuje nastepujace rzeczy:

• zawartosc (inventory)

Obiekt moze "zawierac" inne obiekty. W rzeczywistosci jest to zwykla lista obiektow, ktore sa trzymane wewnatrz obiektu posiadajacego te liste. Jednakze bardzo proste jest uwidocznienie tego, jako ekwipunku gracza, wnetrza torby, pokoju, pudelka itp.

• srodowisko (environment)

Obiekt "otaczajacy" inny obiekt, odwrotnosc zawartosci. Jesli obiekt A jest w ‘ekwipunku’ obiektu B, to obiekt B otacza obiekt A. Obiekt moze miec wiele innych obiektow w swoim ‘ekwipunku’, lecz tylko jeden obiekt-srodowisko. Wszystkie nowo utworzone obiekty nie maja zadnego srodowiska.

• lista komend

Lista polecen powiazanych z funkcjami. Obiekt udostepnia polecenia wszystkim "zyjacym" obiektom, ktore sie znajduja zarowno w jego ekwipunku jak i w srodowisku. Zyjace obiekty moga wydac takie polecenie i obiekt udostepniajacy je wywola powiazana z poleceniem funkcje.

• wlasciwosci (properties)

Wlasciwosci sa czysto umowna sprawa. Jest to najzwyklejszy w swiecie mapping, ktorego indeksy sa jakimis zarezerwowanymi nazwami, a wartosci zmiennymi, ktore wplywaja na jakies ogolnie dostepne stany. Typowymi wlasciwosciami sa waga, cena, poziom swiatla i nieco bardziej abstrakcyjne pojecia takie jak mozliwosc upuszczenia, wziecia czy sprzedania obiektu. Mozliwy do uzycia zestaw wlasciwosci zalezy juz od konkretnych obiektow.

• poziom swiatla

Obiekt ma okreslony poziom swiatla. Zazwyczaj nie wplywa on na otoczenie, choc mozliwe sa do utworzenia zarowno zrodla swiatla, jak i zrodla ciemnosci. Poziom swiatla jest jedna z wlasciwosci.

• waga/objetosc

Wartosci te okreslaja, jak duzo obiekt wazy i ile miejsca zajmuje. W przypadku ‘pojemnikow’ takich jak torby definiuje to takze ich pojemnosc.

• widzialnosc

Niektore obiekty moga byc latwiejsze do znalezenia niz inne.

• nazwy i opisy

Jak obiekt sie nazywa i jakim widzi go gracz.

Standardowe klasy obiektów

Istnieje spora liczba standardowych obiektow, ktorych sie uzywa (stosuje sie termin ‘dziedziczy’) w roznych sytuacjach. By dowiedziec sie nieco wiecej o kazdym z nich, bedziesz potrzebowal osobnej dokumentacji. Ten spis dostepnych obiektow standardowych ma za zadanie przynajmniej ukierunkowac cie w poszukiwaniach.

Jak juz wczesniej mowilem, wiekszosci z nich nie wykorzystuje sie na codzien. Z kilkoma jednak wkrotce staniesz sie za pan brat, gdyz opisywanych przez nie typow obiektow nie da sie napisac nie dziedziczac ich.

• /std/armour.c

Dowolne zbroje

• /std/board.c

Tablice ogloszeniowe

• /std/book.c

Ksiazka ktora mozesz otwierac i zamykac, ze stronami, ktore mozesz przewracac i czytac.

• /std/coins.c

Podstawa wszystkich rodzajow pieniedzy

• /std/container.c

Dowolny obiekt, ktory moze zawierac w sobie inne (pojemnik)

• /std/corpse.c

Cialo martwych potworow/graczy/NPC-ów (NPC – Non Player Charater, czyli wszystkie zyjace istoty, ktore nie sa graczami)

• /std/creature.c

Proste zyjace istoty

• /std/domain_link.c

Dziedziczone przez obiekty uczestniczace w tzw. ‘preloadingu’ (po kazdej Apokalipsie, przed dopuszczeniem graczy do gry, wazniejsze obiekty sa od razu wczytywane do pamieci, by zredukowac laga)

• /std/door.c

Drzwi, ktore lacza dwa pokoje

• /std/food.c

Jedzenie roznego rodzaj

• /std/guild (katalog)

Obiekty zwiazane z gildiami (gildie i shadowy)

• /std/heap.c

Obiekty dowolnego rodzaju, ktore moga byc umieszczone w stosach

• /std/herb.c

Ziola

• /std/key.c

Klucze do drzwi

• /std/leftover.c

Pozostalosci po rozlozonych cialach

• /std/living.c

Zyjace obiekty

• /std/mobile.c

Przemieszczajace sie zyjace obiekty

• /std/monster.c

Dowolne potwory

• /std/npc.c

Sprytniejsze istoty humanoidalne

• /std/object.c

Podstawowy obiekt

• /std/poison_effect.c

Obsluguje dzialanie roznych trucizn

• /std/potion.c

Mikstury

• /std/receptacle.c

Dowolnego rodzaju pojemniki, ktore mozna otwierac/zamykac

• /std/resistance.c

Obsluguje odpornosci na rozne rzeczy

• /std/room.c

Dowolny rodzaj lokacji

• /std/scroll.c

Pergaminy, kartki itp

• /std/shadow.c

Uzywane jako podstawa w tworzeniu obiektow typu ‘shadow’

• /std/spells.c

Obiekty czarow, tomow itp

• /std/torch.c

Pochodnie/lampy itp.

• /std/weapon.c

Bronie wszelakiej masci

Standardowe obiekty biblioteczne

To sa pomocnicze pliki. Uzywa sie ich w polaczeniu z obiektami z katalogu ‘/std/’. Na przyklad chcac zakodowac karczme, dziedziczymy ‘/std/room.c’ oraz ‘/lib/pub.c’.

• /lib/bank.c

Dowolny rodzaj banku

• /lib/cache.c

‘Cache’ uzywany w celu przyspieszenia regularnie wykorzystywanych obiektow

• /lib/guild_support.c

Dodatkowe funkcje dla gildii

• /lib/herb_support.c

Dodatkowe funkcje do ziol

• /lib/more.c

Mozliwosc ‘more’ (przegladania plikow)

• /lib/pub.c

Funkcje przydatne przy pisaniu karczm

• /lib/shop.c

Sklepy dowolnego rodzaju

• /lib/skill_raise.c

Trenowanie umiejetnosci

• /lib/store_support.c

Pomocne funkcje w magazynach (niezbedny dodatek do sklepow)

• /lib/time.c

Funkcje obslugujace czas

• /lib/trade.c

Pomocne we wszystkim co jest zwiazane z handlem

Jak zdobyć odnośniki do obiektów

Obiekty, jak juz wczesniej mowilem, wystepuja w dwoch rodzajach – twz. „master object” i „klon”. W wiekszosci przypadkow operuje sie na sklonowanych obiektach. Sa to miedzy innymi takie, ktore mozesz przesunac, dotknac, obejrzec itp, lub dowolne inne, ktore wystepuja w wiecej niz jednej kopii. Operowanie na „master objectach” ogranicza sie zazwyczaj do pokoi i souli (soule to obiekty wykorzystywane przez obiekty graczy, ktore dodaja im rozne komendy).

Kazdy zaladowany obiekt ma swoj „master object”, ktory jest reprezentacja tego obiektu w pamieci, a zarazem pierwszym klonem. Zawiera on informacje o mechanizmie dzialania obiektu. Klony skladaja sie jedynie z zestawu zmiennych i odnosnika do swojego „master objectu”. Ow zestaw zmiennych odroznia poszczegolne klony od siebie (np. dwa miecze tego samego typu moga sie roznic stopniem stepienia).

Jesli zniszczysz „master object”, jego klony istniejace juz w grze pozostana (informacja o mechanizmie dzialania obiektu gdzies pozostanie w pamieci). Zwiazany jest z tym blad w mysleniu wielu poczatkujacych czarodziejów: Uwazaja, ze przeladowujac „master object” do nowej postaci (po zmianach ktore wprowadzili w kodzie), zmienia sie wszystkie juz istniejace klony. Nic bardziej mylnego – po przeladowaniu (updatowaniu) „master objectu” dopiero nowe klony beda zawieraly wprowadzone zmiany.

Ladowanie „master objectu” do pamieci odbywa sie poprzez wywolanie na sciezce do jego pliku dowolnej, nieistniejacej funkcji (sciezka do pliku stanowi jeden ze sposobow na odniesienie sie do „master objectu”).

Przeladowywanie obiektu (zwane rowniez jego uaktualnianiem lub updatowaniem) polega usunieciu z pamieci starego „master objectu” i zaladowaniu nowego.

Jak w takim razie zdobyc odnosnik do obiektu? To zalezy. Odnosnikiem do obiektu moze byc zarowno wskaznik do obiektu, jak i sciezka do zrodla obiektu w systemie plikow. Metody ich uzyskiwania sa rozne w roznych sytuacjach. Wytlumacze teraz je wszystkie.

Odnośniki do aktualnego obiektu

 [this_object, previous_object, calling_object]

Kazdy obiekt zawsze moze zdobyc odnosnik do samego siebie. Sluzy do tego efunkcja ‘this_object()’:

    object this_object()
    np.
        object ja;
    
        ja = this_object();

Zeby zbadac ktory obiekt wywolal aktualnie uruchomiona funkcje za pomoca wywolania zewnetrznego, mozna uzyc efunkcji ‘previous_object()’:

    object previous_object(void|int glebokosc)
    np.
        object p_ob, pp_ob;
    
        p_ob = previous_object();     // Obiekt, ktory wywolal te funkcje
        pp_ob = previous_object(-2);  // Obiekt, ktory wywolal inny obiekt,
                                      // ktory wywolal te funkcje

Jesli nie podasz zadnego argumentu, albo podasz -1, funkcja zwroci obiekt, ktory ja wywolal. Zmniejszanie argumentu spowoduje podanie dalszych poprzednikow, np. ‘previous_object(-4)’ zwroci obiekt, ktory wywolal obiekt, ktory wywolal obiekt, ktory wywolal twoj obiekt. O ile lancuch wywolan byl na tyle dlugi. Jesli glebokoscia przekroczy sie dlugosc lancucha wywolan, to funkcja zwroci 0.

Mam nadzieje, ze zauwazyles, ze funkcja ta sprawdza tylko zewnetrzne wywolania. Istnieje inna efunkcja, ktora dziala tak samo, tyle ze dla wszystkich rodzajow wywolan (wewnetrzne lub zewnetrzne):

    object calling_object(void|int glebokosc)

Uzywa sie jej tak samo jak poprzedniej

A wiec... skad mozesz wiedziec czy ktory odnosnik wlasnie dostales jest wlasciwy czy nie (tzn. ze to nie jest np. zero albo cos innego)? Jesli jeszcze pamietasz, istnieje pewna efunkcja zwana ‘objectp()’? Doskonale by sie do tego celu nadawala – zwroci 1, jesli podany argument bedzie prawidlowym wskaznikiem do obiektu.

    int objectp(mixed ob)
    np.
        if (objectp(calling_object(-2)))
            write("Tak, ob ktory wywolal ob, ktory nas wywolal " +
                  "istnieje!\n");
        else
            write("Nie ma takiego.\n");

Tworzenie obiektów

 [setuid, getuid, seteuid, geteuid, creator, set_auth, query_auth,

clone_object]

Wpierw musisz sie upewnic, ze obiekt, ktory probuje stworzyc inny ma do tego wystarczajace przywileje. Reguly sa bardzo proste: Obiekt, ktory ma wlasciwe euid moze klonowac dowolny inny obiekt. Wlasciwe euid, to dowolne, rozne od 0. Uid i Euid jest standardowo ustawiane na 0 we wszystkich nowych obiektach i oznacza, ze obiekt wogole nie ma przywilejow.

Zazwyczaj masz ograniczony wybor euid, ktory mozesz ustawic obiektom. Jesli jestes zwyklym wizardem ogranicza sie on tylko do twojego imienia. Lord moze jako euid wstawic swoje imie, lub dowolnego innego wizarda w swojej domenie (wyjatkiem sa tylko Archowie). I oczywiscie obiekty z uid ‘root’ moga ustawic dowolne euid jakie chca.

A wiec... uid jest nadrzedne w stosunku do euid. Uid ogranicza euid jakie mozesz ustawic. Stanowi maksymalny poziom, jaki mozna ustawic euid. Standardowa wartosc uid ustawia sie poprzez wywolanie sfunkcji setuid():

    void setuid()
    np.
        setuid();

Proste, nie? Wykonanie tej komendy spowoduje przypisanie uid uzyskanego z pozycji zrodla pliku w systemie plikow. Dziala to na takich samych zasadach jak w pobieraniu wartosci zwracanej przez sfunkcje creator(), co zostalo opisane wczesniej.

    string creator(mixed odnosnik)
    e.g.
        string moj_tworca;
    
        moj_tworca = creator(this_object());

Aby poznac wartosc aktualnego uid, uzywa sie sfunkcji ‘getuid()’.

    string getuid()
    np.
        string aktualny_uid;
    
        aktualny_uid = getuid();

Wiec... uid ma juz stawiony maksymalny priorytet, taki jaki ma klonujacy. Euid jednakze jest caly czas rowne 0. Poniewaz euid ustala rzczywiste przywileje, bedzie to oznaczalo, ze obiekt nie ma jeszcze zadnych praw.

Do nadawania wartosci euid uzywa sie sfunkcji ‘seteuid()’, gdzie jako argument podaje sie nowa wartosc euid, o ile ma sie prawa, zeby tak ustawic (jest to sprawdzane). Funkcja zwraca 0 w razie niepowodzenia. Nie podanie zadnego argumentu spowoduje wyzerowanie euid.

    int seteuid(void|string przyw)
    np.
        if (seteuid("lewy"))
           write("Wlasnie TAK! Jestem panem WSZECHSWIATA!\n");
        else
            write("Ehhhhh...\n");

Jak zwykle jest podobna sfunkcja, ktora zwraca aktualne euid:

    string geteuid()
    np.
        write("Aktualnym euid jest " + geteuid() + .\n");

Wszystkie sfunkcje ‘setuid()’, ‘getuid()’, ‘seteuid()’ i ‘geteuid()’ korzystaja z efunkcji ‘set_auth()’ i ‘get_auth()’. Uzywa sie ich do zmieniania specjalnej zmiennej z prawami w danym obiekcie. W razie proby uzycia ‘set_auth()’ gamedriver wywoluje specjalna funkcje kontrolna w master object, ktora sprawdza czy ma sie do tego odpowiednie prawa. Jest tak, gdyz tej zmiennej mozna przypisac dowolny string, a sposob w jaki jej uzywamy jest sztucznie ustalony, tak jak uznalismy, ze najlepiej bedzie rozwiazac to w systemie bezpieczenstwa.

Kiedy probujesz wykonac operacje, ktora wymaga odpowiednich przywilejow, taka jak zapisywanie do pliku, czy klonowanie obiektu, to gamedriver wywoluje inne specjalne funkcje w master object, zeby sie upewnic czy masz odpowiednie prawa. Wszystko to zalezy od tego, czy informacje zawarte w zmiennej z prawami maja scisle okreslona, wymagana postac. W zwiazku z tym nie jestes w stanie zdzialac nic wiecej za pomoca ‘set_auth()’, niz bys mogl z ‘setuid()’ i ‘seteuid()’. ‘query_auth()’ nie jest zabezpieczone przed wywolywaniem, lecz nie znajdziesz tam zadnych ciekawych informacji.

Tak prawde mowiac, informacja zawarta w zmiennej z prawami, ktorej to wartosc zwraca ‘query_auth()’ ma po prostu postac uid i euid oddzielonych dwukropkiem.

Skoro juz wiemy jak nadawac przywileje innym obiektom, sprobujmy korzystajac z nich cos sklonowac. Efunkcja do tego celu sluzaca nazywa sie ‘clone_object()’. Laduje i tworzy obiekt z pliku zrodlowego. Gdy operacja klonowania sie nie uda, na przyklad ze wzgledu na jakies bledy w kodzie pliku zrodlowego, zostanie wyswietlony komunikat bledu zas wykonanie obiektu przerwane.

    object clone_object(string sciezka)
    np.
        object magiczny_pierscien;
    
        // Tak sie ustawia prawa obiektu do klonowania
        setuid();          // pobiera uid na podstawie katalogu
        seteuid(getuid()); // jako euid podstawia pobrane uid
    
        // No i samo klonowanie
        magiczny_pierscien = clone_object("/d/Domena/wiz/mag_pierscien");

Oczywiscie wystarczy, ze ustawisz uid/euid obiektu RAZ – pozniej juz nie musisz tego robic przed wykonaniem kazdej operacji, ktora wymaga odpowiednich praw. Najbardziej rozpowszechniona metoda jest umieszczenie wywolan funkcji ustawiajacych uid/euid w funkcji, ktora jest wywolywana w momencie tworzenia obiektu – ale o tym pozniej.

A teraz... tablice i mappingi istnieja tak dlugo, jak dlugo korzystaja z nich jakies zmienne. Gdy ostatnia zmienna odnoszaca sie do nich zostaje wyzerowana, to dane zawarte w nich sa rowniez czyszczone. Czy jest tak samo z obiektami? NIE! Obiekt pozostanie w grze tak dlugo, jak gamedriver jest uruchomiony lub dopoki doraznie go nie zniszczysz.

Odnajdywanie odnośników do innych obiektów

 [file_name, find_object, object_clones, find_living, set_living_name,

MASTER_OB, IS_CLONE]

Jak juz mowilem odnosniki do obiektow moga byc zarowno stringami jak i wskaznikami do obiektow. Zamienianie odnosnika ze wskaznika w lancuch znakowy robi sie przy pomocy efunkcji ‘file_name()’:

    string file_name(object ob)
    np.
        write("To jest obiekt: " + file_name(this_object()) + ".\n");

String, zwracany przez ‘file_name()’ jest tekstowa reprezentacja wskaznika do obiektu. Ma postac ‘<sciezka do pliku>#<numer obiektu>’, na przyklad ‘"/d/Domena/wiz/mag_mikstura#2321"’. Ten lancuch jest wlasciwym odnosnikiem do danego obiektu.

Aby zamienic tekstowy odnosnik do pliku we wskaznik, uzywa sie efunkcji ‘find_object()’.

    object find_object(string odn_ob)
    np.
        object obiekt;
    
        // Master object
        obiekt = find_object("/d/Domena/wiz/mag_mikstura");
    
        // Konkretny klon
        obiekt = find_object("/d/Domena/wiz/mag_mikstura#2321");

Jesli funkcja nie znajdzie obiektu (moze byc podana zla sciezka, dany klon moze nie istniec lub obiekt moze byc nie zaladowany), to zwraca 0.

Czasem przydaje sie miec odnosniki do wszystkich klonow danego obiektu. Do znalezienia ich sluzy efunkcja ‘object_clones()’. Zwroci ona tablice zawierajaca wskazniki wszystkich klonow master objectu, na ktory wskazuje odnosnik podany jako argument. Oznacza to, ze mozesz podac zarowno wskaznik do master objectu, jak i do jednego z jego klonow – nie robi to roznicy. Jesli funkcja nie bedzie w stanie znalezc zadnych klonow, to zwroci pusta tablice.

    object *object_clones(object odn_ob)
    np.
        object *lista_klonow;
    
        lista_klonow = object_clones(find_object("/d/Domena/wiz/mag_mikstura"));

Niektore obiekty nazywa sie "zyjacymi" (living). W grze objawia sie to miedzy innymi tym, ze moga one zostac zaatakowane i (byc moze) zabite. Zyjace obiekty rejestruja sie na specjalnej liscie w gamedriverze. Robia to po to, by mozna je latwiej znalezc. Specjalna efunkcja ‘find_living()’ szuka w tej liscie podanej nazwy zyjacego obiektu.

    object *find_living(string imie, void|int 1)
    np.
        object balrog_ob, *balrogowie;
    
        // Szuka potwora 'balrog' w grze.
        balrog_ob = find_living("balrog");

Jesli podasz ‘1’ jako drugi argument, efunkcja zwroci liste wszystkich obiektow z ta nazwa.

    balrogowie = find_living("balrog", 1);

Jesli efunkcja nie bedzie mogla znalezc obiektu z podanym imieniem, zwroci 0.

Zeby obiekt znalazl sie na liscie imion, musi w sobie wywolac efunkcje ‘set_living_name()’.

    void set_living_name(string imie)
    np.
        // Jest to czesc funkcji create() w kodzie balroga.
        set_living_name("balrog");

Pamietaj o tym, ze jesli masz wiele obiektow z ta sama nazwa, to ‘find_living()’ zwroci losowo jeden z nich.

Zeby zdobyc odnosnik do master_objectu obiektu do ktorego masz wskaznik, musisz zamienic go na stringa i wtedy oderwac od niego numer klonu. Istnieje juz jednak makro znajdujace sie w standardowym pakiecie ‘/sts/macros.h’ robiace to za ciebie. Po prostu dodaj na poczatku pliku linijke ‘#include <macros.h>’ i uzyj makra ‘MASTER_OB’.

    string MASTER_OB(object ob)
    np.
        string master;
    
        // Zalozmy ze /sys/macros.h juz zostalo przylaczone do tego pliku.
        master = MASTER_OB(find_living("balrog"));

Makro zwraca odnosnik do master objectu balroga w postaci tekstowej, wiec jesli chcesz miec wskaznik do master objectu musisz posluzyc sie funkcja ‘find_object()’, jako argument podajac swiezo uzyskany string.

Klon najlatwiej odroznic od master objectu poprzez porownywanie tekstowego odnosnika. W tym celu mozna uzyc makra IS_CLONE. Jest ono rowniez dostepne w ‘/sys/macros.h’. Korzysta ono z ‘this_object()’ i nie wymaga zadnego argumentu.

    int IS_CLONE
    np.
        if (IS_CLONE)
            write("Jestem klonem!\n");

Odnośniki do interaktywnych obiektów

 [find_player, this_interactive, this_player]

Jesli szukasz jakiegos konkretnego gracza, to do cego celu moglbys uzyc ‘find_living()’, a potem upewnic sie, ze zwrocona wartosc jest interaktywnym obiektem. Jednakze o wiele szybciej jest uzyc efunkcji ‘find_player()’, ktora robi dokladnie to samo, z jednym wyjatkiem – moze byc tylko jeden gracz o podanym imieniu w grze. Jesli bedzie on aktualnie zalogowany, to otrzymasz do niego odnosnik.

    object *find_player(string imie)
    np.
        object lewy;
    
        lewy = find_player("lewy");
    
        if (pointerp(lewy))
            lewy->catch_msg("Siemanko, bracie!\n");
        else
            write("Eh.. chyba go nie ma.\n");

Bardzo czesto potrzeba wiedziec kto wydal komende, ktora zapoczatkowala wykonanie jakiejs okreslonej funkcji. Efunkcja ‘this_interactive()’ zwroci do niego wskaznik. Jesli lancuch komend zostal zapoczatkowany przez jakis niezalezny, nieinterakcyjny obiekt, to zwroci ona 0.

Czesciej jednak nie interesuje cie kto zapoczatkowal lancuch, lecz raczej na kogo dany obiekt kieruje swoja uwage. Ten wlasnie obiekt zwroci efunkcja ‘this_player()’. Innymi slowy, podczas gdy obiekt powinien zwracac uwage (listy komend, komunikaty, itp) na obiekt podany przez this_player(), inny gracz zwrocony przez ‘this_interactive()’ mogl stac sie przyczyna wykonania lancucha komend w aktualnym obiekcie. Wartosc ‘this_interactive()’ nigdy nie moze byc zmieniana, w przeciwienstwie do wartosci ‘this_player()’. Wiecej o tym bedzie pozniej.

    object this_player();
    object this_interactive();
    np.
        object tp, ti;
    
        tp = this_player();
        ti = this_interactive();
    
        if (objectp(ti))
        {
            if (ti != tp)
            {
                tp->catch_msg("Zapppp!\n");  // Ale genialne tlumaczenie,
                ti->catch_msg("Zapnales go!\n");  // nie? :-)
            }
            else
                ti->catch_msg("Fzzzzz...\n");
        }

Niszczenie obiektów

 [destruct, remove_object]

Predzej czy pozniej bedziesz chcial sie pozbyc jakiegos obiektu. Sluzy do tego efunkcja ‘destruct()’. Jednakze gamedriver pozwoli tylko na zniszczenie samego siebie, tzn. na wywolanie destruct() tylko z obiektu ktory ma byc zniszczony – zadne wywolanie zewnetrzne nie wchodzi w rachube. To oznacza, ze kazdy obiekt potrzebuje funkcji, ktora wywoluje destruct(), ktora moglbys wywolac z innego obiektu, zeby moc zniszczyc go z zewnatrz. Jesli jednak obiekt nie zawiera funkcji korzystajacej z ‘destruct()’, to nie bedziesz w stanie go ruszyc w ten sposob.

Istnieje wyjscie z tego, ktore umozliwia ci zniszczenie dowolnego obiektu, ale jest nim komenda, ktora musisz wydac wlasnorecznie. Nie mozesz uzyc jej z wewnatrz programu.

Standardowy obiekt, ktory pozniej bedzie bardziej szczegolowo omowiony, definiuje funkcje ‘remove_object()’, ktora mozesz wykonac, aby zniszczyc obiekt. Poniewaz wszystkie obiekty w grze MUSZA dziedziczyc go, mozesz miec pewnosc, ze w kazdym znajdziesz te funkcje. Mozliwe jest zamaskowanie jej i co za tym idzie zablokowanie. Robienie tego, bedzie jednak zwyklym sabotazem, wiec nawet nie mysl o robieniu czegos takiego. Pozwolilismy na jej maskowanie, dlatego zebys mogl dodac tam jakis kod, ktory w razie niszczenia obiektu zrobi kilka innych rzeczy, a nie po to bys mogl pisac niezniszczalne obiekty.

    void remove_object()
    np.
        void
        usun_balroga(string imie_bal)
        {
            object bal;
    
            bal = find_living(imie_bal);
            if (objectp(bal))
                bal->remove_object();
        }

Gdy bezposrednio uzywasz ‘destruct()’ albo wywolujesz w tym samym obiekcie ‘remove_object()’, DWA razy sie upewnij, ze zaden kod nie jest po tym wykonywany. Widzisz, wykonywanie nie jest przerywane od razu po komendzie do zniszczenia – obiekt jest tylko oznaczany jako „juz zniszczony”, a sama destrukcja dzieje sie po skonczeniu wykonywania go. Oznacza to, ze wywolania funkcji lub komendy wydane po komendzie destrukcji moga spowodowac bledy runtime w innych obiektach.

    void destruct()
    np.
        void
        zniszcz_mnie()
        {
            write("Zegnaj, okrutny swiecie!\n");
            destruct();
        }

Gdy obiekt jest niszczony, WSZYSTKIE wskazniki do niego (nie odnosniki tekstowe) w grze sa ustawiane na 0. Ze wzgledu na ten fakt, warto sie upewnic, czy stary wskaznik do obiektu jest wciaz wlasciwy, przed robieniem z nim czegokolwiek. Nigdy nie masz pewnosci – moze zostal usuniety w miedzyczasie.

Jesli niszczony obiekt zawiera jakies inne obiekty, to w czasie destrukcji one sa rowniez usuwane. Wyjatkiem sa obiekty interakcyjne, gracze. Kiedy uaktualniasz (update) pokoj, skutecznie go niszczysz. Jesli sa w nim jacys gracze, to zostana oni przemieszczeni do startowych lokacji. Jesli dany pokoj jest startowa lokacja lub jest jakis problem z przemieszczaniem ich tam (bledny kod lokacji, albo niemoznosc przemieszczenia), to ci gracze zostana rowniez usunieci.

Obsługa poleceń przez obiekty

 [init, add_action, enable_commands, disable_commands, living, command,

commands, get_localcmd, query_verb, notify_fail, update_actions]

Jak na razie wiesz na pewno, ze nic w tej grze nie jest proste. Aby pogmatwac wydawanie polecen, mamy ich dwa rodzaje. Jednym z nich jest taki, o ktorym juz wczesniej mowilismy, czyli polecenia definiowane przez ‘fizyczne’ obiekty. Drugim rodzajem sa komendy twz. soul (duszowe?). Sa one wymyslem czysto mudlibowym. Bedzie o nich mowa w trzecim rozdziale.

Polecenia dodane przez fizyczne obiekty dzialaja w ten sposob: Po wejsciu takiego obiektu w kontakt z innym obiektem, np. graczem (czyli:

albo 1:obiekt wchodzi w ekwipunek ("zawartosc" obiektu) gracza,

albo 2:gracz i obiekt znajduja sie we wspolnym srodowisku, np. w tym samym pokoju,

albo 3:gracz wchodzi w "zawartosc" obiektu np do pokoju),

w obiekcie ktory wszedl wolana jest lfunkcja ‘init()’. Jest ona zwykla funkcja, taka jak kazda inna, lecz przeznaczona jest do dodawania polecen poprzez efunkcje ‘add_action()’. Innymi slowy, gdy wchodzisz do jakiegos obiektu, do listy twoich polecen zostaja dodane polecenia z nowego srodowiska, z twojego ekwipunku oraz polecenia innych obiektow bedacych w tym samym srodowisku co ty.

Funkcja ‘add_action()’ przypisuje polecenie jakiejs funkcji. Po wpisaniu slowa-polecenia, zostaje wykonana polaczona funkcja, z argumentem stanowiacym reszte wpisanego polecenia (np. gdyby cale polecenie brzmialo ‘zabij zielonego smoka’, to slowem-poleceniem byloby ‘zabij’, a argumentem ‘zielonego smoka’). Oprocz poprzednich dwoch argumentow(tj. funkcja oraz slowo-polecenie), add_action() moze przyjac rowniez trzeci. Jesli rowna sie on 1, to przypisana funkcja bedzie wykonana, nawet gdy komenda bedzie stanowila tylko czesc zdefiniowanego w add_action() polecenia. Na przyklad, jesli zdefiniowane polecenie brzmialoby ‘zabij’, to wywolanie przypisanej funkcji mogloby byc dokonane juz przez komende "za" albo "zab".

    add_action(function funkcja, string slowo_polecenie, void|int 1)
    np.
        init()
        {
            /*
             * Funkcje 'zrob_uklon()' i 'wyjdz_z_gry()' sa zdefiniowane
             * gdzies w tym obiekcie. Jednakze, jesli ich deklaracje
             * znajduja sie za ta funkcja, to w naglowku programu musza 
             * byc ich prototypy.
             */
            add_action(zrob_uklon, "uklon");    // Przyzwyczaj sie lepiej
            add_action(&wyjdz_z_gry(), "quit"); // do roznych rodzajow
                                                // deklaracji odnosnikow
                                                // do funkcji.
        }

Czy jest to prawda dla kazdego rodzaju obiektu? Czy kazdy obiekt otrzyma ten zestaw komend? Ano nie. Tylko "zyjace" obiekty. Obiekt moze zostac uczyniony "zyjacym" poprzez efunkcje ‘enable_commands()’, a martwym badz bezwladnym poprzez efunkcje ‘disable_commands()’. Zauwaz, ze „zyjacy” obiekt dla gamedrivera oznacza „taki, ktory moze przyjmowac i wydawac polecenia” – dla mudliba znaczy to troche wiecej.

Mozesz uzywac tych efunkcji za kazdym razem, gdy zechcesz wlaczyc lub wylaczyc zdolnosc to obslugiwania polecen w obiekcie. Pamietaj tylko o tym, ze gdy "ozywisz" obiekt, to nie przybedzie mu komend z racji tego, ze znajduje sie np w pokoju ktory dodaje polecenia. Sa one dodawane tylko przy wchodzeniu do srodowiska pokoju. Zeby je uzyskal bedziesz musial wiec przeniesc go z, a potem spowrotem do pomieszczenia.

Mozesz sprawdzic, czy obiekt jest "zyjacy" przy pomocy efunkcji ‘living()’.

    enable_commands()
    disable_commands()
    int living(object ob)
    np.
        public void
        zmien_stan_ozywienia()
        {
            if (living(this_object()))
                disable_commands();
            else
                enable_commands();
        }

Polecenia moga byc dodawane i obslugiwane tylko przez obiekty, ktore sie znajduja w srodowisku lub zawartosci danego obiektu. Kiedy jest on usuwany z zasiegu obiektow dodajacych polecenia, mozliwosc ich wykonania jest rowniez usuwana.

Jak widzisz, gamedriver oczekuje, ze funkcja ‘init()’ jest zdefiniowana w kazdym obiekcie, ktory chce dodac polecenia zyjacym obiektom. Badz jednak ostrozny w czasie uzywania tej funkcji. Jesli na przyklad uzywasz ‘init()’ do sprawdzania, czy wchodzacy obiekt ma prawo sie tam znalezc i przenosi go gdzies jesli nie ma prawa, to najprawdopodobniej bedziesz mial klopoty. Bedzie tak dlatego, ze gdy sprobujesz dodac polecenia juz po przesunieciu, to w rzeczywistosci bedziesz to robil na nieobecnym obiekcie. Gamedriver spostrzeze to i skonczy sie to bledem. Chcialbym ci doradzic, bys nie uzywal funkcji ‘init()’ do zadnych innych celow, niz do dodawania polecen. Mozesz ewentualnie sprawdzac czy obiekt, ktory wywolal ‘init()’ powinien otrzymac polecenia, czy nie (jesli chcesz ograniczyc dostep do niektorych polecen), ale nie wrzucaj tam niczego innego.

W wiekszosci obiektow, ktore dziedzicza posrednio lub bezposrednio podstawowy obiekt, musisz wywolac takze rodzica ‘init()’, gdyz bez tego twoj init() moze stracic kilka bardzo waznych rzeczy. Po prostu umieszczaj instrukcje ‘::init();’ na poczatku kazdego swojego init'a, jeszcze przed instrukcjami ‘add_action()’, a wszystko bedzie w porzadku.

Aby wykonac jakies polecenie w zyjacym obiekcie, uzyj efunkcji ‘command()’.

    int command(string komenda)
    np.
        command("kichnij");
        command("zaloz helm");

Aby otrzymac liste dostepnych polecen, uzywa sie efukcji ‘commands()’ lub ‘get_localcmd()’ w zaleznosci od tego, jakiego typu informacji sie potrzebuje. ‘commands()’ zwraca tablice tablic, zawierajacych wszystkie komendy dostepne dla okreslonego obiektu plus te, ktore obiekt sam definiuje wraz z funkcjami, ktore sa w razie ich wykonania wywolywane. ‘get_localcmd()’ jest prostsza i zwraca tylko tablice z slowami-poleceniami. Gdy zaden obiekt nie jest wyszczegolniony, uzywa sie jako standardowej wartosci ‘this_object()’. Obejrzyj manuala dla ‘commands()’ by dowiedziec sie jaki format ma zwracana tablica.

    mixed commands(void|object ob)
    string *get_localcmd(void|object ob)

Gdy uzywasz jednej funkcji do wielu slow-polecen, zachodzi potrzeba zbadania, ktore konkretnie zostalo uzyte. Do tego uzywa sie efunkcji ‘query_verb()’.

    string query_verb()
    np.
        init()
        {
            ::init();
            add_action(&moja_funkc(), "apa");  // wszystkie trzy
            add_action(moja_funkc, "bepa");    // polecenia wywoluja
            add_action(&moja_funkc(), "cepa"); // te same funkcje...
        }
    
        public int
        moja_funkc()
        {
            switch (query_verb()) // ...ale kazde polecenie jest w niej
            {                     // rozpatrywane oddzielnie
            case "apa":
                < kod >
                break;
    
            case "bepa":
                < kod >
                break;
    
            case "cepa":
                < kod >
                break;
            }
            return 1;
        }

Funkcje obslugujace polecenia powinny zwracac 1, gdy zostaly poprawnie uzyte, tzn kiedy zostala wywolana wlasciwa funkcja, z wlasciwym argumentem. Kiedy zwrocisz 0, gamedriver bedzie szukal innych funkcji przypisanych do identycznego slowa-polecenia, do czasu az ktoras z nich zwroci 1, albo nie bedzie juz zadnych innych. Jest specjalna efunkcja zwana ‘notify_fail()’, ktorej mozesz uzyc do przechowania komunikatu bledu, ktory zostanie wyswietlony gdy zadna z funkcji nie ‘przygarnie’ polecenia. Zamiast standardowego, bezsensownego komunikatu bledu ‘What?’, mozesz dac graczowi wydajacemu polecenie jakas lepsza informacje (na Arkadii ‘Slucham?’). W przypadku gdy wszystkie funkcje powiazane z identycznym slowem poleceniem zwroca 0, to ostatnio zdefiniowany ‘notify_fail()’ zostanie uzyty do wyswietlenia komunikatu bledu.

    notify_fail(string komunikat)
    np.
        public void
        init()
        {
            ::init();
            add_action(&zrob_uklon(), "uklon");
        }
    
        public int
        zrob_uklon(string komu)
        {
            if (!find_player(komu))
            {
                notify_fail("Nie tu nikogo takiego!\n");
                return 0;
            }
    
            < kod uklonu >
    
            return 1;
        }

Jesli jestes absolutnie pewien, ze polecenie odnosilo sie do twojego obiektu i chcesz przerwac wykonanie nawet jesli twoj obiekt znalazl w nim blad (zle argumenty, kontekst, lub cokolwiek innego), to mozesz zwrocic 1. Pamietaj jednak, ze wtedy musisz uzyc innej metody wyswietlenia komunikatu bledu na ekranie niz ‘notify_fail()’, gdyz ta funkcja ma szanse byc uzyta tylko gdy zwrocisz 0.

Gdy twoj obiekt zmienia dostepne polecenia w czasie swojego dzialania i chcesz, by okoliczne zyjace obiekty uaktualnily swoj zestaw komend, musisz wywolac efunkcje ‘update_actions()’ na swoim obiekcie. Jesli nie sprecyzujesz w argumencie zadnego obiektu, to domyslnie zostanie przyjety ‘this_object()’. Wszystkie okoliczne zyjace obiekty uniewaznia stary zestaw komend od twojego obiektu i wywolaja sobie jeszcze raz ‘init()’ z niego, zeby pobrac nowy zestaw.

    update_actions(object ob)

Alarmy: Niesynchroniczne wywołania funkcji

 [set_alarm, remove_alarm, get_alarm, get_all_alarms]

Gamedriver oblicza tak zwany „evaluation cost”, albo prosciej „eval cost” (koszt wykonania). Jest to zwykly sposob mierzenia, jak bardzo obiekt obciaza CPU. Kazdy obiekt ma nadany limit kosztu wykonania. Kiedy jest on wyczerpany, wykonanie obiektu zostaje przerwane. Ograniczenie to zostalo narzucane, by gra nie byla za dlugo przeciazana. Istnienie tego pociaga za soba jednak pewne konsekwencje. Jakies duze obliczenia moga sie po prostu nie zmiescic w limicie eval costu, wiec w takiej sytuacji potrzeba rozbic program na mniejsze czesci.

Czasem przydaje sie opoznic wykonanie jakiejs funkcji, a czasem warto, by funkcja byla wykonywana cyklicznie. Pozwala na to wykorzystanie alarmow. Ustawia sie je efunkcja ‘set_alarm()’.

    int set_alarm(float opoznienie, float cykl, function funkcja_alarm)
    remove_alarm(int alarm_id)
    mixed get_alarm(int alarm_id)
    mixed get_all_alarms()

Funkcja zwraca unikalny dla tego obiektu numer alarmu, ktory mozesz pozniej wykorzystywac do manipulowania nim. Informacje o danym alarmie uzyskuje sie wywolujac funkcje ‘get_alarm()’, jako argument podajac numer alarmu. Do usuwania ich sluzy efunkcja ‘remove_alarm()’, a do zdobycia informacji o wszystkich alarmach sluzy efunkcja ‘get_all_alarms()’. Ta ostatnia jest przewaznie wykorzystywana w sytuacjach, gdy zapomni sie przechowac gdzies identyfikator alarmu, albo chce sie wyswietlic informacje o obiekcie. Efunkcja ‘set_alarm()’ pozwala na ustalenie opoznienia, po jakim podana funkcja zostanie wykonana po raz pierwszy, oraz opoznienia pomiedzy kolejnymi cyklicznymi wywolaniami. Kazde wywolanie alarmu zaczyna sie z eval costem rownym 0. Poniewaz funkcje sa wywolywanie przez alarm niesynchronicznie wzgledem uzytkownika obiektu, ‘this_player()’ i ‘this_interactive()’ zwroca 0. Pamietaj o tym, gdyz niektore efunkcje korzystaja z wartosci zwracanej przez ‘this_player()’.

UWAGA! PRZECZYTAJ TO UWAZNIE!

Bardzo latwo wpasc w nawyk dzielenia programu na wiele ‘alarmowych’

wywolan w malych odstepach czasowych. Jednakze NIE do tego sluza alarmy. Smiertelnym grzechem jest robienie funkcji alarmowej, ktora tworzy powtarzajace sie alarmy wewnatrz powtarzajacych sie alarmow. Ilosc alarmow wtedy gwaltownie wzrasta i CALA GRA momentalnie staje. Jest to tak nieprawdopodobnie kretynskie, ze grozi natychmiastowym demotem, wiec upewnij sie, ze wszytko jest W PORZADKU za pierwszym razem. Ogolnie rzecz biorac, odstepy pomiedzy cyklicznymi alarmami, powinny byc dluzsze niz jedna dwie sekundy, tak samo jak odstepy przed pojedynczymi wywolaniami.

Funkcje alarmowe beda szerzej opisane i zademonstrowane w trzecim rozdziale.

Środowisko i zawartość

 [move_object, move, enter_inv, enter_env, leave_inv, leave_env,

environment, all_inventory, deep_inventory, id, present]

Jak juz wczesniej mowielem, kazdy obiekt ma zarowno „wnetrze”, jak i „otoczenie”. Otoczenie, lub inaczej mowiac „srodowisko” moze byc tylko jednym obiektem, podczas gdy we wnetrzu, w „zawartosci” moze sie znajdowac wiele obiektow.

Swiezo sklonowany obiekt znajduje sie w swego rodzaju pustce, gdyz nie ma zadnego srodowiska. Zeby mogl znalezc sie w fizycznym swiecie gry, musi byc tam przesuniety. Jednakze, nie wszystkie obiekty moga byc przemieszczane. Zeby DOWOLNY obiekt, ktory chce byc gdzies umieszczony, albo chce samemu zawierac jakies inne obiekty dzialal, MUSI dziedziczyc ‘/std/object.c’ gdzies w swoim lancuchu dziedziczen. Po co to ograniczenie? Dlatego, ze standardowy obiekt definiuje spora liczbe pomocnych funkcji i inne obiekty polegaja na tym, ze beda one w twoim obiekcie.

Oto najwazniejsze sposrod nich:

• move()

Przemieszcza obiekt do innego, obslugujac rachunek wagi/objetosci. Zwraca, czy przesuniecie powiodlo sie. Jest odpowiedzialna za wywolywanie nastepujacych funkcji:

• enter_inv()

Wywolywana jest w obiekcie, gdy inny obiekt wchodzi w jego zawartosc.

• leave_inv()

Wywolywana w obiekcie, gdy inny obiekt wchodzi w jego zawartosc.

• enter_env()

(!!!)

• leave_env()

(!!!)

UWAGA! Powyzsze funkcje beda wywolane TYLKO wtedy gdy to wlasnie ‘move()’ zostanie uzyty do przesuniecia. Dlatego tak wazne jest to, zebys przemieszczal w ten sposob, a nie poprzez efunkcje, ktora robi to bezposrednio.

Lfunkcja ‘move()’ korzysta z efunkcji ‘move_object()’. ALE pamietaj, gdy odwolasz sie bezposrednio do tej drugiej, to stany obiektu takie jak oswietlenie, waga, czy objetosc nie zostana uaktualnione. Jak juz poprzednio mowilem, fiaskiem skonczy sie proba przeniesienia obiektu do innego przy pomocy ‘move_object()’, gdy ktorys z nich nie dziedziczy ‘/std/object.c’. Dodatkowo, efunkcja moze byc wywolana tylko z obiektu, ktory chce byc przesuniety. To samo dotyczy oczywiscie lfunkcji ‘move()’.

W celu uzyskania odnosnika do obiektu srodowiska, uzywa sie efunkcji ‘environment()’. Jak juz wczesniej powiedzialem, zaden obiekt nie ma zdefiniowanego srodowiska zaraz po utworzeniu – otrzymuje je dopiero, gdy jest gdzies przenoszony. Kiedy obiekt chociaz raz opusci ‘pustke’, w ktorej sie znajduje na poczatku, to juz nigdy nie moze tam wrocic, tzn. nie mozna przeniesc obiektu do ‘0’. Obiektami, po ktorych mozesz sie spodziewac, ze nie beda mialy zadnego srodowiska sa pokoje, dusze, cienie i obiekty daemon.

Masz do wyboru dwie funkcje, sposrod ktorych mozesz wybierac, gdy chcesz zdobyc sklad obiektu. Efunkcja ‘all_inventory()’ zwraca tablice ze wszystkimi obiektami bedacymi zawartoscia podanego obiektu. Efunkcja ‘deep_inventory()’ zwraca tablice, zawierajaca nie tylko to, co ‘all_inventory()’, ale rowniez obiekty, ktore sa we wnetrzu obiektow, ktore sa we wnetrzu podanego obiektu, itd.

    object *all_inventory(object ob)
    object *deep_inventory(object ob)
    np.
    /*
     * Funkcja wyswietla ekwpipunek Fatty na ekranie. Od argumentu bedzie
     * zalezalo, czy bedzie to tylko ekwipunek widoczny na pierwszy rzut
     * oka, czy caly.
     */
    void
    fatty_powiedz_aaaaa(int wszystko)
    {
        object fatty_ob, *listaob;
    
        if (!objectp((fatty_ob = find_player("fatty"))))
        {
            write("Przykro mi, Fatty nie ma dzis w grze.\n");
            return 0;
        }
    
        listaob = wszystko ? deep_inventory(fatty_ob) 
                           : all_inventory(fatty_ob);
    
        write("Oto " + (wszystko ? "cala " : "") +
                    " zawartosc wielkiego brzucha Fatty:\n");
        dump_array(listaob);
    }

Co powiesz na sprawdzenie, czy dany obiekt jest obecny w zawartosci innego? Bazowy obiekt ‘/std/object.c’ definiuje zarowno nazwe jak i opis w obiektach. Rowniez w nim znajduje sie lfunkcja ‘id()’, ktora sprawdza czy podany argument jest jedna z nazw danego obiektu. Jesli jest to zwraca 1(prawde). Efunkcja ‘present()’ przeszukuje zawartosci obiektow, sprawdzajac czy jest tam obiekt o podanym odnosniku lub nazwie. Gdy w argumencie wpiszesz to drugie, to ‘present()’ skorzysta z poprzednio omowionej funkcji ‘id()’ do sprawdzenia, czy w przeszukiwanym aktualnie obiekcie istnieje takowa nazwa. Wykonanie funkcji skonczy sie tak szybko, jak szybko znajdzie ona pierwszy pasujacy do opisu obiekt. Oznacza to, ze jesli jest wiecej takich obiektow, to funkcja zwroci ci tylko jeden z nich.

    object present(object ob|string odnob, object *listaob|object ob|void)
    np.
    /*
     * Szuka orzeszkow u Fatty
     */
    void
    znajdz_orzeszek()
    {
        object fatty_ob;
    
        fatty_ob = find_player("fatty");
    
        // Nie mozna znalezc Fatty!
        if (!objectp(fatty_ob))
        {
            write("Fatty chwilowo nie ma, sprobuj pozniej.\n");
            return;
        }
    
        if (present("orzeszek", fatty_ob))
            write("Tak, Fatty wydaje sie byc bardzo zadowolony z zycia.\n");
        else
            write("Na twoim miejscu trzymalbym sie z dala od " +
                  "Fatty, dopoki nie zaspokoi glodu.\n");
    }

Jesli nie podasz drugiego argumentu w ‘present()’, to funkcja poszuka obiektu w zawartosci ‘this_object()’, czyli tego obiektu, z ktorego zostala wywolana. Gdy w drugim argumencie podasz tablice, to funkcja przeszuka wszystkie obiekty z listy. Jesli nie znajdzie niczego, to zwroci 0.

Funkcje obsługujące łancuchy znakowe

 [break_string, capitalize, lower_case, sprintf, strlen, wildmatch]

W srodowisku gry opartym na tekscie, naturalne jest to, ze tworcy zadali sobie troche trudu w stworzeniu latwych i wszechstronnych funkcji obslugujacych lancuchy znakowe. Jak juz wiesz, stringi mozna sumowac przy pomocy operatora ‘+’, a nawet laczyc je z liczbami calkowitymi bez zadnych klopotow. Floaty i wskazniki do obiektow musza juz jednak byc konwertowane. Te pierwsze przy pomocy efunkcji ‘ftoa()’ (opisanej pozniej), a te drugie poprzez juz opisana efunkcje ‘file_name()’.

Jedna z najczesciej sprawdzana rzecza w stringach, poza tym co zawieraja, jest ich dlugosc. Uzyskuje sie ja przy pomocy efunkcji ‘strlen()’. Jako argument mozna podac rowniez liczby calkowite (zwroci wtedy 0), dzieki czemu mozna ja wykorzystywac takze do sprawdzania czy zmienna typu string zostala juz zainicjalizowana.

    int strlen(string str)
    np.
        string str = "Fatty jest spasionym, zatwardzialym szowinista";
        write("Dlugosc stringa '" + str + "' wynosi " + strlen(str) +
              " znakow.\n");

Nieraz zachodzi potrzeba takiego przeformatowania stringa, by zaczynal sie z duzej litery. Sluzy do tego efunkcja ‘capitalize()’. Oprocz tego istnieje efunkcja ‘lower_case()’, ktora zamienia wszystkie litery w podanym stringu na male.

    string capitalize(string str)
    string lower_case(string str)

np.

    void
    // Wyswietli podane imie, odpowiednio sformatowane.
    wyswietl_ladne_imie(string imie)
    {
        string nowe_imie;
    
        // Zalozmy, ze imie = "fAttY"
        nowe_imie = lower_case(imie);
        // Teraz imie = "fatty"
        nowe_imie = captialize(imie);
    
        write("Imie brzmi: " + imie + "\n");
    
        /* Efektem jest:
    
           Imie brzmi: Fatty
         */
    }

Czasem przydaloby sie polamac stringa na mniejsze kawalki(np dlugosci linijki ekranu), by ladniej wygladal i nadawal sie do wyswietlenia. Sluzy do tego efunkcja ‘break_string()’. Dzieki niej mozesz nawet dodac spacje na poczatku polamanych lancuchow znakowych. Jej dzialanie polega na wstawianiu znaku nowej linii po odpowiedniej ilosci slow, tak by jedna czesc zmiescila sie w podanym limicie znakow. Trzeci argument mowiacy ile ma byc spacji wciecia, albo podajacy string wstawiany na poczatku kazdego fragmentu jest opcjonalny.

    string break_string(string str, int dlug_lam, 
                        int dlugosc_wciecia|string wstawiany_string|void)

np.

        string str = "To jest string, ktory chce przedstawic na rozne " +
                     "sposoby.";
    
        write(break_string(str, 26) + "\n");
        write(break_string(str, 26, 5) + "\n");
        write(break_string(str, 26, "Fatty mowi: ") + "\n");
    
        /* Efektem bedzie:

           To jest string, ktory chce
           przedstawic na rozne
           sposoby.
                To jest string, ktory chce
                 przedstawic na rozne
                sposoby.
           Fatty mowi: To jest string, ktory chce
           Fatty mowi: przedstawic na rozne
           Fatty mowi: sposoby.
         */

Bardzo czesto bedziesz chcial przedstawic zawartosc zmiennej na ekranie. Jak juz pokazalem, mozesz to zrobic poprzez zamienienie wartosci zmiennej w stringa i wyswietlenie jej. Integerow nawet nie trzeba konwertowac - wystarczy, ze dodasz go przy pomocy operatora ‘+’. Otrzymasz jednak cos, co nie bedzie sformatowane i byc moze bedzie wymagalo jakis przerobek. Czasem mozesz chciec wyswietlic tresc zmiennych w postaci tabelki i bedziesz wtedy musial bawic sie w rozne duperele takie jak uzaleznianie ilosci spacji od dlugosci zmiennej itp. Zamiast tego, mozesz skorzystac z efunkcji ‘sprintf()’.

‘sprintf()’ pobiera dwa stringi. Pierwszy to jest ten, ktory chcesz przeformatowac. Drugi zas zawiera wskazowki, wedlug ktorych formatowanie ma sie odbywac. Wynikiem jest gotowy lancuch znakow, ktory mozesz wyswietlic np. przy pomocy ‘write()’.

Wszystkie znaki z drugiego stringa, poza specjalnymi zaczynajacymi sie od ‘%’ beda przekopiowane do wynikowego stringa. Znaki kontrolne maja postac: "%<wyznacznik szerokosci><wyznacznik typu>".

Szerokosc jest liczba calkowita, oznaczajaca dlugosc „okienka” w ktorym dane beda wyswietlane oraz czy dana ta ma byc rownana do lewej czy do prawej strony. Dodatni numer oznacza, ze do prawej, zas ujemny, ze do lewej. Jesli nie podasz szerokosci, to zmienna zostanie wlozona w okienko o dlugosci rownej dlugosci zmiennej. Wyznacznik typu sklada sie z jednej lub wiecej liter, okreslajacych jaki typ zmiennej bedzie tu uzyty.

A oto lista wyznacznikow typu:

• d
• i

Argument jest liczba calkowita.

         string str;
         int a;
         a = 7;
         str = sprintf("test: >%-3d%i<", 1, a);
         
         write(str + "\n");
         
         // Efektem jest:
         // test: >1  7<

• s

Argument jest lancuchem znakow.

• c

Podany argument jest numerem ASCII, znaku ktory ma byc wyswietlony.

• o

Liczba ma byc przedstawiona w systemie osemkowym.

• x

Liczba ma byc przedstawiona w systemie szesnastkowym.

• X

Liczba ma byc przedstawiona w systemie szesnastkowym (duzymi literami).

• O

Argument jest typem danych LPC. Jest to swietna rzecz do wyszukiwania bledow (odpluskwiania), gdyz mozesz wyswietlic dzieki niej zawartosc DOWOLNEJ zmiennej.

np.

         write(sprintf("1:%d 2:%s 3:%c 4:%o\n5:%x 6:%X 7:%O\n", 5,
                       "hupp happ", 85, 584, 32434, 85852, strlen));
         
         // Efektem bedzie:
         // 1:5 2:hupp happ 3:U 4:1110
         // 5:7eb2 6:14F5C 7:<<FUNCTION &strlen()>>

Specyfikator ten jest jak na razie jedynym, w ktorym da sie wyswietlic floaty.

To byla lista wszystkich wyznacznikow typow. Do wyznacznikow szerokosci mozna jeszcze dodac te elementy:

• ' '

Liczbowy argument zostanie poprzedzony jedna spacja, o ile jest dodatni. Pozwala to na robienie fajnych tabel bez zawracania sobie glowy tym, ze liczby z minusem zajmuja o jeden znak wiecej.

• +

Dodatnie argumenty liczbowe zostana poprzedzone plusem.

• 'X'

Znak(i) w apostrofach bedzie poprzedzal argument.

• |

Argument zostanie wycentrowany w okienku.

         write((sprintf(">%19|s<\n", "Fatty grubas")));

         // Efektem bedzie:
         // >   Fatty grubas    <

• #

Oznacza to tryb tablicowy. Efektem bedzie lista slow oddzielonych ‘\n’ w tabeli o szerokosci okienka. Oczywiscie mozna uzyc tego tylko do stringow.

• =

Ten wyznacznik jest poprawny tylko dla stringow. Wyswietla rezultat w kolumnach, o ile argument jest szerszy od okienka.

• *

Argument obok gwiazdki jest rozmiarem okienka. Jesli polaczysz to z trybem tablicowym, to otrzymasz fajne tabelki.

• @

Argumentem jest tablica. Oczywiscie musisz polaczyc to z wyznacznikiem typu, zaznaczajac typ elementow.

Bardzo czesto zachodzi potrzeba sprawdzenia, czy dany string jest czescia jakiego innego. Jesli nie jestes zainteresowany informacja gdzie on dokladnie wystapil, a tylko czy wogole, to efunkcja ‘wildmatch()’ bedzie czyms w sam raz dla ciebie. Po prostu zwraca 1, jesli podany string wystapil gdzies, w jakims innym, wiekszym stringu. Mniejszy string moze skladac sie tez z prostych symboli-masek.

• *

Odpowiada dowolnej liczbie dowolnych znakow (użyteczne np. przy szukaniu stringa typu „obojętnie kto mowi: ty draniu obojętnie co”)

• ?

Odpowiada jednemu dowolnemu znakowi

• [xyz]

Porownuje dowolne znaki sposrod tych w nawiasach kwadratowych

• [^xyz]

Porownuje dowolne znaki nie bedace pomiedzy nawiasami kwadratowymi

• \c

Porownuje c, nawet jesli jest to znak specjalny

    int wildmatch(string matryca, string str);

np.

        // Cokolwiek, co sie konczy na .foo
        wildmatch("*.foo", "bar.foo") == 1
        // Cokolwiek zaczynajacego sie od a, b lub c i zawierajacego
        // conajmniej jeden znak wiecej
        wildmatch("[abc]?*", "axy") == 1
        wildmatch("[abc]?*", "dxy") == 0
        wildmatch("[abc]?*", "a") == 0

Funkcje obsługujące znaczniki bitowe

 [clear_bit, set_bit, test_bit]

Nieraz zachodzi potrzeba przechowania sporej liczby informacji typu ‘tak/nie’. Bardzo prostym i przy okazji niezbyt dobrym sposobem byloby stworzenie sporej liczby integerow, po jednym na kazda informacje i wstawianie w nie 0 albo 1, zeby przedstawic jakis stan. Daje to latwy dostep i jest zrozumiale, ale jak przychodzi do przechowania wiekszej ilosci informacji, to sie zaczynaja problemy z straszna pamieciozernoscia tej metody.

Zamiast tego, mozna uzywac stringow, gdzie kazdy bit w znaku (jest ich 8 na znak) moze przechowywac informacje typu tak/nie. Maksymalna liczba bitow w lancuchu wynosi okolo 1200 = dlugosc stringa okolo 150 znakow. Choc raczej watpie, ze wykorzystasz je wszystkie.

Poszczegolne bity ustawia sie przy pomocy efunkcji ‘set_bit()’, ktora wymaga dwoch argumentow. Pierwszym jest zmienna typu string, w ktorej bit ma byc ustawiony, drugim zas numer bitu, ktory chcesz wlaczyc. ‘clear_bit()’ dziala analogicznie do ‘set_bit()’, tylko ze zeruje(wylacza) podany bit. Jesli chcesz sprawdzic jaka wartosc zawiera dany bit, to powinienes uzyc efunkcji ‘test_bit()’.

Nie musisz inicjalizowac stringow, ktore chcesz wykorzystac do przechowywania bitow. Zarowno ‘set_bit()’ jak i ‘clear_bit()’ zwracaja zmodyfikowany string, a w przypadku gdy nie jest on wystarczajaco szeroki to zostanie rozszerzony przez ‘set_bit()’. ‘clear_bit()’ jednakze nie skroci stringa.

    string set_bit(string bitstr, int numer_bitu)
    string clear_bit(string bitstr, int numer_bitu)
    int test_bit(string bitstr, int numer_bitu)
    np.
        // Wlacza 23 bit
        string bf;
    
        bf = "";
        bf = set_bit(bf, 22);
    
        // Zeruje 93 bit
        bf = clear_bit(bf, 92);
    
        // Sprawdza 3 bit
        if (test_bit(bf, 2))
            write("Wlaczony!\n");
        else
            write("Wyzerowany!\n");

Funkcje obsługujące czas

 [time, ctime, file_time, last_reference_time, object_time]

Z jakiejs nieznanej przyczyny wszystkie pomiary czasu w UNIXe, a co za tym idzie w mudzie, zaczynaja sie od 1 stycznia 1970 roku. Byc moze tworcy tego systemu wymyslili sobie, ze z komputerowego punktu widzenia nie ma powodu, by chciec ustawic jakas wczesniejsza date. W kazdym razie tak jest i nic na to nie mozna poradzic. Mierniki czasu sa integerami i zliczaja czas od wyzej wymienionej daty w sekundkach.

Efunkcja ‘time()’ zwraca aktualny czas. Mozesz wykorzystac ja w tej postaci, albo przekonwertowac zwracana wartosc w jakis zrozumialy string przy pomocy efunkcji ‘ctime()’. W celu otrzymania czasu, w ktorym plik zostal utworzony, uzywa sie efunkcji ‘file_time()’. Istnieje analogiczna efunkcja odnoszaca sie do obiektow – ‘object_time()’.

Warto czasem wiedziec kiedy ostatni raz obiekt byl uzywany, tzn. kiedy ostatni raz byla wywolana w nim jakas funkcja. Jesli jako pierwsza instrukcje wywolasz ‘last_reference_time()’ to otrzymasz ten czas. Pamietaj jednakze, ze po wykonaniu tej funkcji, czas ostatniego wywolania przyjmie wartosc czasu biezacego.

    int time()
    string ctime(int tm)
    int file_time(string obref)
    int object_time(object ob)
    np.
        // last_reference_time() wywolujemy jako pierwsze
        write("Ten obiekt ostatni raz byl uzyty " + 
            ctime(last_reference_time()) + "\n");
        write("Aktualny czas: " + ctime(time()) + ".\n");
        write("Ten obiekt istnieje juz " + 
            (time() - object_time(this_object())) + " sekund.\n");

Funkcje obsługujące konwersję tablice-stringi

 [explode, implode]

Istnieje mozliwosc podzielenia stringa na mniejsze kawalki na podstawie jakiegos innego lancucha, albo sklejenia roznych stringow umieszczonych w tablicy w jeden. Do tego celu sluza efunkcje ‘explode()’ i ‘implode()’.

Efunkcja ‘explode()’ wymaga dwoch argumentow: pierwszym jest string, ktory chce sie podzielic, drugim zas jakis inny string, ktorego ‘explode()’ szuka w wiekszym jako znacznika, gdzie go podzielic (np. explode(jakis_tekst, " ") zwroci jakis_tekst podzielony na slowa;

znacznikiem dzielacym jest tutaj spacja). 

Efunckja zwraca tablice skladajaca sie z podzielonych stringow. ‘implode()’ jako argumentow wymaga tablicy i stringa, a zwraca string skladajacy sie z posklejanych elementow tablicy, polaczonych stringiem z drugiego argumentu.

    string *explode(string str, string matryca)
    string implode(string *lista_str, string str_laczacy)
    np.
        string owoce = "jablko i banan i ananas " +
                       "i pomarancz i fatty ktory je to wszystko";
        string *lista_owocow;
    
        lista_owocow = explode(owoce, " i ");
        dump_array(lista_owocow);
    
        /* Efektem bedzie:
            (Array)
            [0] = (string) "jablko"
            [1] = (string) "banan"
            [2] = (string) "ananas"
            [3] = (string) "pomarancz"
            [4] = (string) "fatty ktory je to wszystko"
         */
    
         owoce = implode(lista_owocow, ", ");
         write(owoce + "\n");
    
        // Efektem bedzie:
        // jablko, banan, ananas, pomarancz, fatty ktory je to wszystko

Funkcje obsługujące tablice

 [allocate, member_array, sizeof, pointerp]

Zaczne od malej powtorki z tablic. Moga one zawierac dowolne typy danych, wlaczajac w to inne tablice. Pamietaj o tym, ze tablice w przeciwienstwie do typow danych (poza mappingami) sa kopiowane poprzez odnosnik, a nie poprzez wartosc. Oznacza to, ze gdy przypisujesz tablice zmiennej, nie kopiujesz jej, a jedynie przechowujesz odnosnik, wskaznik do tablicy w zmiennej.

    np.
        string *arr1, *arr2;
    
        arr1 = ({ 1, 2, 3 });
        arr2 = arr1;
    
        arr2[1] = 5;
    
        dump_array(arr1);
        /*
         * Efektem jest:
         *
         * (Array)
         * [0] = (int) 1
         * [1] = (int) 5
         * [2] = (int) 3
         */

A wiec jak widzisz, zmiana zawartosci tablicy ‘arr2’ zmienia rowniez zawartosc tablicy ‘arr1’. Zeby uczynic ja unikalna, musisz wpierw wykonac kopie ‘arr1’, na przyklad poprzez dodanie do niej pustej tablicy ‘({ })’.

Jak juz wiesz, tablice beda automatycznie zaalokowane poprzez zwykle wpisanie czegos w nie badz poprzez dodanie elementu lub innej tablicy. Jesli jednak chcesz natychmiast zaalokowac tablice do odpowiedniego rozmiaru to mozesz uzyc efunkcji ‘allocate()’. Rozmiar podaje sie jako jedyny argument. Funkcja zainicjalizuje podana liczbe elementow i ustawi je wszystkie na 0, niezaleznie od typu tablicy.

    mixed *allocate(int rozmiar)
    np.
        string *str_tabl;
    
        str_tabl = allocate(3);
        str_tabl[1] = "Fatty jest sflaczalym szowinista";
        dump_array(str_tabl);
    
        /* Efektem jest:

            (Array)
            [0] = (int) 0
            [1] = (string) "Fatty jest sflaczalym szowinista"
            [2] = (int) 0
         */

Jesli chcesz sprawdzic, czy dane wyrazenie jest elementem tablicy i jesli tak, to jaki jest indeks tego elementu, to mozesz skorzystac z efunkcji ‘member_array()’, podajac jako argumenty tablice i szukany element. Funkcja zwroci numer indeksu, jesli znajdzie element, albo -1 gdy poszukiwania zakoncza sie niepowodzeniem. Jesli w tablicy bedzie wiecej odpowiadajacych elementow, to ‘member_array()’ zwroci indeks pierwszego z nich.

    int member_array(mixed element, mixed tablica)

np.

        int *tab = ({ 1, 55443, 123, -3, 5, 828, 120398, 5, 12 });
        int indeks;
    
        // Wszystkie '5' zostana zastapione przez '33'
        while ((indeks = member_array(5, tablica)) != -1)
            tab[indeks] = 33;

Bardzo wazna efunkcja dotyczaca tablic jest ‘sizeof()’. Zwraca ona rozmiar podanej tablicy, tzn. liczbe elementow znajdujacych sie w niej. Czesto zachodzi potrzeba napisania petli oblatujacej wszystkie elementy tablicy, albo po prostu znalezienia indeksu ostatniego elementu i wtedy ta efunkcja sie bardzo przydaje.

UWAGA! Indeks ostatniego elementu wynosi rozmiar_tablicy - 1 : (sizeof(tablica) - 1), gdyz numeracja indeksow zaczyna sie od 0.

    int sizeof(mixed tab)
    np.
        string *tab = ({ "Fatty", "szownita" });
    
        write(implode(tab, " ") + " jest zle.\n");
    
        tab[sizeof(tab) - 1] = "szowinista";
    
        write(implode(tab, " ") + " jest poprawnie.\n");

Efunkcja ‘pointerp()’ moze byc zastosowana do sprawdzenia, czy zmienna zawiera tablice (dowolnego typu), czy nie. Jest bardzo przydata, jesli masz doczynienia z funkcjami, ktore moga zwrocic 0 (wartosc NULL), gdy cos pojdzie nie tak jak powinno.

    int pointerp(mixed tab)
    np.
        string *tab;
    
        if (pointerp((tab = find_player("zdzichu")->pobierz_gildie())))
            write("Zdzichu nalezy do: " + implode(tab, ", ") + ".\n");
        else
            write("Zdzichu nie nalezy do zadnej gildii!.\n");

Funkcje obsługujące Mappingi

 [mkmapping, mappingp, m_sizeof, m_delete, m_indices, m_values,
  m_restore_object, m_save_object]

Tak jak to wczesniej mowilem, mappingi sa listami indeksow powiazanych z wartoscami. Podajac indeks, otrzymujesz przypisana do niego wartosc. Zawartosc mappingow jest ulozona w specjalnie posortowany sposob, dzieki czemu dostep do nich jest bardzo szybki. Jednakze maja pewna wade – sa strasznie pamieciozerne i zuzywaja bardzo duzo miejsca w porownaniu do tablic.

Jak sie alokuje mappingi? Jest to bardzo proste. Wystarczy, ze zadeklarujesz go, a potem przypiszesz jedna wartosc do indeksu. Jesli indeks bedzie juz istnial, wartosc przy nim zostanie zastapiona nowa. A jesli nie, to zostanie dodana nowa para. Do tworzenia mappingow mozna tez uzyc efunkcji ‘mkmapping()’ i jako argumenty podac dwie tablice, jedna z samymi indeksami, a druga z wartosciami. Pamietaj tylko, ze musza miec one taki sam rozmiar.

    mapping mkmapping(mixed tab_ind, mixed tab_war)
    np.
        string *ind_tab, *wart_tab;
        mapping mp;
    
        mp["lewy"] = "wielki";
        mp["alvin"] = "straszny";
        mp["fatty"] = "grubas";
    
        // ... jest tym samym co ...
    
        ind_tab = ({ "lewy", "alvin", "fatty" });
        wart_tab = ({ "wielki", "unikalny", "grubas" });
        mp = mkmapping(ind_tab, wart_tab);
    
        // Mozesz oczywiscie podac te tablice bezposrednio,
        // bez poslugiwania sie zmiennymi

Tak jak w tablicach, tu tez jest funkcja sprawdzajaca czy dana zmienna zawiera mapping, czy nie. Jest nia ‘mappingp()’. Uzywaj jej do tego samego celu, tzn. gdy jakas funkcja moze, ale nie musi zwracac mappingu, a ty chcesz miec pewnosc zanim zaczniesz indeksowac zwracana wartosc.

Do znajdywania rozmiaru mappingu moze ci posluzyc efunkcja ‘m_sizeof()’. Dziala dokladnie tak samo, jak odpowiednik u tablic, zwracajac liczbe elementow (par) w mappingu.

W mappingach usuwanie elementow juz nie jest takie proste, jak w tablicach. Sluzy do tego efunkcja ‘m_delete()’. Jej dzialanie nie polega na bezposrednim usunieciu elementu, tylko na stworzeniu nowego mappingu i przekopiowaniu tam zawartosci starego bez podanego elementu.

    mapping m_delete(mapping map, mixed elem)
    np.
        mapping mp, m_nowy;
    
        mp["lewy"] = "wielki";
        mp["alvin"] = "straszny";
        mp["fatty"] = "grubas";
    
        m_nowy = m_delete(mp, "fatty");
        dump_array(m_nowy);
    
        /* Wynik:
         *
         *  (Mapping) ([
         *    "lewy":"wielki"
         *    "alvin":"straszny"
         *  ])
         */

A jak zdobyc wszystkie elementy mappingu? Na przyklad chcielibysmy jakiejs odwrotnosci ‘mkmapping()’. Do tego sluza dwie funkcje: ‘m_indices()’ oraz ‘m_values()’, ktore zwracaja (kolejno) wszystkie indeksy oraz wszystkie wartosci danego mappingu.

Doszlismy do dosyc niestabilnej kwestii – kolejnosci elementow w mappingach. Jak wczesniej mowilem, mappingi nie maja jej na stale zdefiniowanej. Tzn. maja, ale nie jest to temat ktorym powinienes sobie zawracac glowe. Zmienia sie ona gdy dodajesz, albo usuwasz jakas pare. W kazdym razie wazne jest to, ze gdy pobierzesz wszystkie indeksy i wartosci z jakiegos mappinga (za pomoca m_indices() i m_values()), to elementy otrzymanych tablic beda sobie odpowiadaly o ile pomiedzy pobieraniami nie wykonywales zadnych operacji na tym mappingu.

    mixed m_indices(mapping mapp);
    mixed m_values(mapping mapp);
    np.
        // Funkcja wyswietla mapping i jego zawartosc
        void
        dump_mapping(mapping mp)
        {
            int i, sz;
            mixed ind, war;
    
            ind = m_indices(mp); // Pomiedzy tymi dwoma intrukcjami, nie
            war = m_values(mp); // powinno byc zadnych dzialan na mappingu.
    
            sz = sizeof(ind);
    
            for (i = 0 ; i < sz ; i++)
                write(sprintf("%O", ind[i]) + " przypisane do " +
                      sprintf("%O", war[i]) + "\n");
        }
    
        /* Na przyklad uruchamiamy: dump_mapping(([ "fatty" : "grubas",
         *                                          "lewy" : "wielki",
         *                                          "alvin" : "straszny"
         *                                         ]));
         * Otrzymujemy:
         *
         * "alvin" przypisane do "straszny"
         * "fatty" przypisane do "grubas"
         * "lewy" przypisane do "wielki"
         */

Sa, albo beda dwie funkcje, ktore zapisuja i odtwarzaja dane obiektu. Niestety, jak na razie maja one jeszcze bledy i nie dzialaja dokladnie tak, jakbysmy sobie tego zyczyli. Powinny one funkcjonowac w ten sposob: ‘m_save_object()’ stworzy mapping, zawierajacy wszystkie globalne, nie-statyczne zmienne, ktorych nazwy beda indeksami. Bedziesz mogl wtedy zgrac go bezposrednio do pliku, albo przekazac go dalej, jako argument jakiejs funkcji. Odwrotnoscia tego bedzie funkcja ‘m_restore_object()’. Bedzie ona przyjmowala mapping jako argument, rozkladala jego elementy ustawiajac zmiennym globalnym odpowiadajace wartosci.

Konwersja typów

 [atoi, atof, ftoa, itof, ftoi, str2val, val2str, sscanf]

Wiekszosc rzeczy wpisywanych przez gracza to stringi; wpisujesz cos i gra powinna odpowiednio na to zareagowac. Wymaga to istnienia funkcji, ktore zanalizuja twoje komendy i przetlumacza to na wartosci, ktorych mozesz uzyc w swoich programach. Analiza skladni komend, jest lekko mowiac bardzo skomplikowana i zostawiam to na trzeci rozdzial. Teraz skupmy sie tylko na konwertowaniu samych wartosci. Jak mowilem, to co gracze wpisuja jest w formie stringow, przez co zamienianie stringow w integery oraz floaty i vice versa moze byc dosyc pozyteczna umiejetnoscia.

Zacznijmy od integerow. Zalozmy, ze otrzymales string zawierajacy jakas wartosc numeryczna i chcesz jej uzyc do jakis obliczen. Musisz wiec przeksztalcic stringa w integera. Sluzy do tego efunkcja ‘atoi()’; podajesz string jako argument i otrzymujesz integer – bardzo proste. Lancuch nie moze jednak zawierac zadnych znakow innych niz cyfry. W przeciwnym wypadku funkcja zwroci 0.

    int atoi(string str)
    np.
        int war;
    
        war = atoi("23");
    
        write("23 + 3 = " + (war + 3) + "\n");

Liczby zmiennopozycyjne (floaty) maja analogiczna efunkcje, ‘atof()’, ktora przeksztalca stringa we floata. Jak juz wiesz, floaty nie moga byc przekonwertowane w stringi w ten sam sposob, jak integery, czyli poprzez dodanie ich do innego stringa. Funkcja ‘ftoa()’ zamienia floata w stringa. Tak samo jak w przypadku ‘atoi()’, jesli w ‘atof()’ podasz jakis string, w ktorym beda znaki nie-numeryczne, to zwroci 0 (wyjatkiem beda specjalne znaki, takie jak np. ‘.’.

Do zamiany pomiedzy integerem a floatem sluza efunkcje ‘itof()’ oraz ‘ftoi()’. Pamietaj tylko, ze gdy zamieniasz floata w integera, to czesc dziesietna nie jest zaokraglana, tylko obcinana.

Jest wiele momentow, w ktorych mozesz chciec przechowac wartosc w stringu, a potem przemienic ja spowrotem. Sluza do tego efunkcje ‘val2str()’ oraz ‘str2val()’. Da sie wyswietlic zawartosc ‘val2str()’, ale nie do tego zostala ona stworzona. Mozesz przechowac dowolna wartosc zmiennej, korzystajac z tych funkcji

Najczesciej jednak uzywanym konwerterem danych jest efunkcja ‘sscanf()’. Mozesz sprecyzowac, gdzie ma ona szukac wartosci (podobnie jak w ‘sprintf()’), w celu pobrania ich i przechowania w jakiejs zmiennej. Jest ona charakterystyczna, gdyz ustawia wartosci zmiennych podanych w argumencie, wiec niemozliwe jest pobranie jej adresu. Poza tym, dziala ona bardzo prosto. Podaje sie matryce, string do przeszukania i zmienne, w ktorych dane powiny byc przechowane. Funkcja zwraca liczbe znalezionych wartosci.

String, ktory podasz jako matryce, jest interpretowany doslownie, z wyjatkiem ponizszych lancuchow kontrolnych.

• %d

porownuje liczbe calkowita.

• %s

porownuje lancuch znakow.

• %f

porownuje liczbe zmiennopozycyjna.

• %%

porownuje znak `%'.

    int sscanf(string str, string matryca, <zmienne>...);
    np.
        int szer;
        float waga;
        string orgstr;
        string typ_szer, typ_wagi;
    
        /*
         * Zalozmy, ze zadawane jest pytanie :
         * "Jak ci sie wydaje, jak ciezki i szeroki jest Fatty?".
         * Oprocz tego zalozmy, ze odpowiedz jest dana w formie
         * '<ilosc> <rodzaj> i <ilosc> <rodzaj>', na przyklad:
         * '4 metry i 3.2 tony'. Przyjmijmy, ze pierwsza wartosc moze byc
         * tylko integerem, a trzecia tylko floatem.
         *
         * Zalozmy jeszcze, ze odpowiedz jest podana w zmiennej `orgstr'
         */
    
        if (sscanf(orgstr, "%d %s i %f %s", szer, typ_szer,
                   waga, typ_wagi) != 4)
        {
            write("Podaj pelna odpowiedz!\n");
            return;
        }
    
        write("Aha, uwazasz, ze Fatty jest szeroki na " + szer + " " +
              typ_szer + " i wazy " + ftoa(waga) + " " + typ_wagi ".\n");

Funkcje matematyczne

 [random, rnd, sin, cos, tan, asin, acos, atan, atan2, exp, log, pow,

sinh, cosh, tanh, asinh, acosh, atanh, abs, fact, sqrt]

Efunkcja ‘random()’ zwraca dowolna liczbe calkowita z zakresu od 0, do podanej w argumencie liczby minus jeden. Na przyklad ‘random(8)’ zwroci losowa liczbe z zakresu 0-7.

Reszta funkcji matematycznych pobiera jako argumenty i zwraca floaty. Funkcje trygonometryczne uzywaja radianow, nie stopni. Pamietaj o tym.

Oto pelna lista funkcji matematycznych:

• float rnd()

Zwraca losowa liczbe z zakresu od 0 do 1

• float sin(float)

Oblicza sinus podanego kata.

• float cos(float)

Oblicza cosinus podanego kata.

• float tan(float)

Oblicza tangens podanego kata.

• float asin(float)

Oblicza arcus sinus z zakresu od -pi/2 do pi/2.

• float acos(float)

Oblicza arcus cosinus z zakresu od 0 do pi.

• float atan(float)

Oblicza arcus tangens z zakresu od -pi/2 do pi/2.

• float atan2(float x, float y)

Compute the argument (phase) of a rectangular coordinate in the range -p to p.

(!!!) – Hmm, ktos wie co to moze znaczyc?

• float exp(float)

Compute the exponential function using the natural logarithm e as base

(!!!) – Rety, nastepny kwiatek... ln do potegi ?

• float log(float)

Oblicza logarytm naturalny.

• float sinh(float)

Oblicza wartosc sinusa hiperbolicznego.

• float cosh(float)

Oblicza wartosc cosinusa hiperbolicznego.

• float tanh(float)

Oblicza wartosc tangensa hiperbolicznego.

• float asinh(float)

Oblicza wartosc arcusa sinusa hiperbolicznego.

• float acosh(float)

Oblicza wartosc arcus cosinusa hiperbolicznego.

• float atanh(float)

Oblicza wartosc arcus tangensa hiperbolicznego.

• float abs(float)

Oblicza wartosc absolutna argumentu (modul).

• float fact(float)

Oblicza silnie (funkcja gamma) podanego argumentu.

• float sqrt(float)

Oblicza pierwiastek kwadratowy podanego argumentu.

Obsługa plików

 [save_object, restore_object, save_map, restore_map, write_bytes,

read_bytes, write_file, read_file, file_size, file_time, rename, rm, ed]

Przechowywania informacji w plikach jest bardzo wazne. Zaraz pokaze ci kilka funkcji, ktore ci w tym pomoga. Pozwol mi jednak strzelic male kazanie, na temat zuzycia CPU:

Odczyt i zapis plikow jest sprawa bardzo obciazajaca CPU. Moze nie w porownaniu do innych procesow, ale podczas operacji dyskowej CPU nie moze robic nic innego. Innymi slowy, wczytywanie i zapisywanie duzych porcji danych znacznie spowalnia gre. Zeby ograniczyc zbyt duze obciazanie pamieci, dysku i CPU, narzucono limit nie pozwalajacy obluzyc wiecej niz 50 kb danych na raz. Pliki moga byc wieksze, ale ty nie mozesz zapisywac ni wczytywac fragmentow wiekszych niz ten limit. Oznacza to, ze musisz podzielic prace nad wiekszymi plikami na kawalki wykonywane sekwencyjnie, z ewentualna przerwa pomiedzy nimi, zeby reszta gry tez miala czas na zrobienie czegos. Wiec, prosze pamietaj o tym, ze to ograniczenie nie zostalo stworzone, by ci utrudnic zycie i zeby bylo obchodzone roznymi kretymi sposobami, tylko aby ci przypominac, ze obciazasz zasoby muda i ze powinienes innym tez dac zyc. Amen.

Zacznijmy od bardzo prostej sprawy: nagrywania i odtwarzania obiektow. Zazwyczaj, chce sie przechowac zmienne globalne obiektu w pliku, po to by je pozniej odtworzyc. Do tego celu sluza efunkcje ‘save_object()’ oraz ‘restore_object()’. W obu musisz podac sciezke wraz z nazwa pliku jako argument i oczywiscie miec prawa do zapisu lub do odczytu. Wynikiem ‘save_object()’ bedzie plik, ktorego nazwa bedzie miala koncowke ‘.o’. Przy odtwarzaniu musisz pamietac o tym, by ja podac. Przy nagrywaniu to nie jest konieczne – funkcja sama doda rozszerzenie ‘.o’, gdy ty o tym zapomnisz. ‘restore_object()’ zwraca 1, gdy odtwarzanie zakonczylo sie sukcesem, zas w przeciwnym wypadku zwraca 0. Zawartoscia nagranego pliku jest lista wszystkich zmiennych globalnych z ich wartosciami, oddzielonymi spacjami. Format zapisu przechowanej zmiennej jest taki sam, jak w przypadku juz omowionej funkcji ‘val2str()’.

Mappingi sa najbardziej wygodnym typem do przechowywania zmiennych. Wystarczy umiescic dane w mappingu, gdzie indeksami sa nazwy zmiennych, a potem nagrac mapping przy pomocy efunkcji ‘save_map()’, by pozniej odtworzyc go poprzez ‘restore_map()’. Przewaga tej metody nad ‘save/restore_object()’ jest to, ze nie jestes ograniczony wylacznie do nie-statycznych zmiennych i mozesz przechowac co ci sie zywnie podoba. Minusem jest to, ze odtwarzanie danych z mappingu jest juz ciut bardziej skomplikowane.

    void save_object(string sciezka_nagr);
    int restore_object(string sciezka_odcz);
    void save_map(mapping mapp, string sciezka_nagr);
    mapping restore_map(string sciezka_odcz);
    np.
        /*
         * Zalozmy, ze mamy takie definicje zmiennych globalnych:
         *
         * string imie, *opis;
         * int flip;
         * mapping dane_map, smap;
         *
         * Zalozmy, ze interesuje nas przechowanie zmiennych imie, opis, 
         *                                         flip i dane_map
         */
    
        // Ustawienie dziedzicznych przywilejow poprzez nadanie obiektowi 
        // euid tworcy pliku
        setuid();
        seteuid(getuid());
    
        // Metoda nagrywania 1
        save_object("mojplik");
        // Metoda odtwarzania 1
        if (restore_object("mojplik"))
            write("Tak!\n");
        else
            write("Nieeee..\n");
    
        // Metoda nagrywania 2
        smap = ([ "imie" : imie,
                  "opis" : opis,
                  "flip" : flip,
                  "dmap" : dane_map ]);
        save_map(smap, "mojplik");
    
        // Metoda odtwarzania 2
        smap = restore_map("mojplik");
        if (m_sizeof(smap))
        {
            imie = smap["imie"];        // Odtwarza imie
            opis = smap["opis"];        // Odtwarza opis
            flip = smap["flip"];        // Odtwarza flip
            dane_map = smap["dmap"];    // Odtwarza dane_map
            write("Tak!\n");
        }
        else
            write("Nieeee..\n");

Musisz zapamietac, ze format zapisu uzywany przez ‘save_object()’ i przez ‘save_map()’ jest taki sam, dzieki czemu mozna odtworzyc plik zapisany przez ‘save_object()’ przy pomocy ‘restore_map()’ i wybrac z otrzymanego mappinga, tylko te elementy, na ktorych nam zalezy. Zalozmy, ze bys chcial odtworzyc tylko zmienna ‘opis’ w powyzszym przykladzie. Nie martwil bys sie wtedy innymi zmiennymi i uzylbys wtedy okrojonej drugiej metody odtwarzania. Uwazaj na odczytywanie danych, ktore zostaly nagrane przez ‘save_map()’ instrukcja ‘restore_object()’. Zeby wszystko bylo poprawnie, indeksy nagranego mappingu musialy by miec takie same nazwy, jak zadeklarowane w obiekcie zmienne globalne. W powyzszym przykladzie sa roznice pomiedzy nimi, wiec odtworzenie metoda 1, danych zgranych metoda 2 skonczyloby sie bledem. W odwrotnej sytuacji, czyli przy wczytywaniu metoda 2 danych przechowanych metoda 1 nie wyskoczy zaden blad, ale nie uda sie odtworzyc zmiennej ‘dane_map’.

To byly wszystkie metody przechowywania zmiennych w plikach. Nieraz moze zajsc potrzeba nagrania danych w wolnej formie, a nie tylko w zmiennych. Do tego celu sluza efunkcje ‘write_bytes()’ i ‘read_bytes()’, albo ‘write_file()’ i ‘read_file()’. W zasadzie obie pary funkcji dzialaja bardzo podobnie, tzn wczytuja i nagrywana stringi o okreslonej dlugosci. Jedyna roznica jest to, ze ‘write_bytes()’ moze byc uzyte do nagrywania na stare dane w pliku (overwriting), podczas gdy ‘write_file()’ jest w stanie zapisywac tylko na koncu. No i ‘read_bytes()’ operuje na bajtach, a ‘read_file()’ na pelnych liniach. Obie zapisujace funkcje zwracaja 1 w przypadku powodzenia, zas 0 w gdy cos sie nie uda. Obie wczytujace funkcje zwracaja string, zawierajacy odczytana porcje danych w przypadku sukcesu, a 0 w przypadku niepowodzenia, wiec sprawdzaj rezultat przy pomocy ‘stringp()’, zeby sie upewnic, ze wszystko bylo ok.

    int write_bytes(string sciezka, int poz, string tekst);
    string read_bytes(string sciezka, void|int poz, void|int num);
    int write_file(string sciezka, string tekst);
    string read_file(string sciezka, void|int poz, void|int num);

O pliku rowniez da sie uzyskac informacje. W poznaniu rozmiaru pliku moze dopomoc efunkcja ‘file_size()’. Mozna ja tez wykorzystac do sprawdzenia obecnosci pliku. Jesli liczba zwrocona przez funkcje jest dodatnia, to oznacza to, ze jest to rozmiar. Gdy nie ma pliku, funkcja zwraca -1, a gdy plik jest katalogiem, -2. Aby poznac czas ostatniej modyfikacji mozna uzyc efunkcji ‘file_time()’.

    int file_size(string sciezka);
    np.
        void plik_info(string sciezka)
        {
            int typ, tm;
    
            rozm = file_size(sciezka);
            tm = file_time(sciezka);
    
            write("Plik '" + sciezka + "' ");
            switch (rozm)
            {
            case -1:
                write("nie istnieje.\n");
                break;
    
            case -2:
                write("jest katalogiem, ostatni raz zmodyfikowanym " +
                    ctime(tm) + ".\n");
                break;
    
            default:
                write("ma rozmiar " + rozmiar + " bajtow, ostatni raz " +
                    "byl zmodyfikowany " + ctime(tm) + ".\n");
                break;
            }
        }

Jesli chcesz zmienic nazwe albo przemiescic plik, to efunkcja ‘rename()’ jest w sam raz dla ciebie. Ale uwazaj, gdyz jej dzialanie polega na skopiowaniu pliku, a potem skasowaniu starej wersji. Moze byc rowniez uzyta do przesuniecia katalogow. Jesli zyczysz sobie usunac caly plik, to mozesz skorzystac z efunkcji ‘rm()’. Zwraca ona 1 w przypadku sukcesu, a 0 w przypadku niepowodzenia. Uwazaj, bo ‘rename()’ dziala dokladnie odwrotnie, gdyz zwraca 1 w przypadku niepowodzenia, a 0 jak wszystko jest ok.

    int rename(string stara_sciezka, string nowa_sciezka);
    int rm(string sciezka);
    np.
        if (rm("mojplik"))
            write("Ok, skasowane.\n");
        else
            write("Sorki, cos nie idzie.\n");
    
        if (rename("plik_stary", "plik_nowy"))
            write("Niestety, wciaz po staremu...\n");
        else
           write("Ok!\n");

Wewnetrzny edytor ‘ed’ jest efunkcja, ktora operuje na plikach. Mozesz go uzywac do czegokolwiek, lecz pamietaj, ze wiekszosc ludzi nie wie jak z niego korzystac. Pamietaj takze, ze efunkcja ‘ed()’ moze byc uzyta do stworzenia nowego pliku, albo edycji starego, na podstawie praw obiektu, ktory ja wywolal. Jesli podasz wskaznik do funkcji, to przy wyjsciu z ‘ed()’ zostanie ona wywolana. Jesli nie podasz sciezki, uzytkownik bedzie musial sam wpisac sciezke i nazwe pliku wewnatrz edytora.

    void ed(void|string sciezka, void|function fun_wyjsciowa);

Obsługa katalogów

 [mkdir, rename, rmdir, get_dir]

Tworzenie, zmienianie nazwy i usuwanie katalogow robi sie przy uzyciu efunkcji (kolejno) ‘mkdir()’, ‘rename()’, ‘rmdir()’. Aby je wykonac musisz oczywiscie miec prawa do zapisu w katalogu, w ktorym to robisz. ‘mkdir()‘ i ‘rmdir()’ zwracaja 1 w przypadku sukcesu, a 0 w razie niepowodzenia. ‘rename()’ jak juz mowilem dziala odwrotnie i zwraca 1 w przypadku niepowodzenia. ‘rmdir()’ kasuje tylko puste katalogi, tzn takie, ktore nie zawieraja zadnych plikow ani katalogow.

    int mkdir(string sciezka);
    int rename(string stara_sciezka, string nowa_sciezka);
    int rmdir(string sciezka);

W celu pobrania zawartosci katalogu uzywa sie efunkcji ‘get_dir()’. Zwraca ona tablice albo zawierajaca wszystkie pliki w podanym katalogu w przypadku sukcesu, albo pusta w przypadku niepowodzenia.

    string *get_dir(string sciezka);
    np.
        string *zawartosc_kat;
        int i, sz;
    
        zawartosc_kat = get_dir("/d/Domena/fatty");
    
        for (i = 0, sz = sizeof(zawartosc_kat) ; i < sz ; i++)
        {
            // Obejrzyj kod funkcji plik_info w poprzednim przykladzie
            file_info(zawartosc_kat[i]);
        }

Wejście/wyjście konsoli

 [write, write_socket, cat, tail, input_to]

Juz zapewne jestes za pan brat z efunkcja ‘write()’, ktora wyswietla dane na ekranie osoby zdefiniowanej jako sluchacz w danym obiekcie. Moze nim byc gracz, ale moze rowniez byc nim jakis inny obiekt. Zazwyczaj funkcja wystarcza, gdy masz pelna kontrole nad tym co i do kogo piszesz. Jednakze istnieje pewna podobna funkcja, ktora czasem staje sie potrzebna. Nazywa sie ona ‘write_socket()’. Dziala ona prawie tak jak ‘write()’, tylko ze wypisuje teksty wylacznie na ekranie interakcyjnego uzytkownika. Jesli nie ma takowego, to zamiast do niego, pisze w glownym logu bledow. W czasie kodowania zwyklych obiektow nie bedziesz musial jej uzywac. Przewaznie, lub nawet zawsze jest wykorzystywana w konkretnych obiektach mudliba, czesciowo tych, ktore maja doczynienia z logujacymi sie graczami.

Wypisywanie write'm jest niezle, ale czasem mozesz miec chrapke na blyskawiczne wyswietlenie plikow, lub przynajmniej ich czesci. Do tego sluzy efunkcja ‘cat()’. Ukaze ona na ekranie okreslona porcje podanego pliku na ekranie. Istnieje tez inna efunkcja zwana ‘tail()’, ktora wyswietli ostatnie 1080 bajtow pliku. ‘cat()’ zwraca liczbe ukazanych linii, zas ‘tail()’ zwraca 1 w przypadku sukcesu, a 0 w przypadku niepowodzenia.

    int cat(string sciezka, int start, int dlug);
    int tail(string sciezka);

np.

        // Wyswietla PLIKTEST, od 20 do 100 linii
        cat("PLIKTEST", 20, 80)
    
        // Wyswietla koncowke tego samego pliku
        tail("PLIKTEST");

Wiekszosc rzeczy wpisywanych w grze przez graczy przychodzi w formie argumentow do funkcji. Czasem jednak potrzeba zapytac gracza o cos, a on musi odpowiedziec. Pojawia sie tu problem, gdyz wykonanie obiektow w gamedriverze jest sekwencyjne; jesli sie zatrzymasz z wykonywaniem czekajac na odpowiedz, cala gra zatrzyma sie wraz z toba, do czasu az leniwy gracz sie namysli (o ile kiedykolwiek) i odpowie. Z pewnoscia taka sytuacja nie jest dobrym rozwiazaniem. Zamiast tego, mozna wywolac efunkcje ‘input_to()’, ktora pozwala ci ustalic ktora funkcja zostanie wywolana majac za argument jakakolwiek odpowiedz gracza, po ukonczeniu wykonywania aktualnej funkcji. Brzmi to troche skomplikowanie, ale na prawde wcale takie nie jest. Spojrz tylko na przyklad:

    void input_to(string funkcja, void|int bezecha, void|mixed arg);

np.

        string imie, plec, zajecie;
    
        pytajaca_fun()
        {
            write("Wpisz swoje imie: ");
            input_to("fun_2");
        }
    
        fun_2(string wpis)
        {
            imie = wpis;
            write("\nWpisz swoja plec (Facet/Kobitka): ");
            input_to("fun_3");
        }
    
        fun_3(string wpis)
        {
            plec = wpis;
            write("\nCzym sie zajmujesz?: ");
            input_to("fun_4");
        }
    
        fun_4(string wpis)
        {
            zajecie = wpis;
            write("\n\nDzieki za wspolprace!\n");
        }

Jesli jako drugi argument do ‘input_to’ podasz 1, to cokolwiek gracz wpisze, nie zostanie wyswietlone na ekranie. Uzywa sie tego przy haslach i innch waznych informacjach. Trzeci, opcjonalny argument jest przekazywany do funkcji, ktora podales jako odbiorce.

Niektóre komendy MUD-a

Moze to wygladac nieco dziwnie, ze rozdzial ten umiescilem tak nisko. Problem ten podobny jest do zagadnienia : co bylo pierwsze jajko czy kura. Uzywanie tych komend jest niemozliwe, zanim nie zrozumie sie na czym to wsystko naprawde polega. By to zrozumiec zawsze mozna empirycznie eksperymentowac z komendami... Jesli rozpoczales lekture tego manualu przed eksperymentowaniem, to rozdzial ten na pewno ci sie przyda.

Prosilbym przede wszystkim bys skupil sie na swoich umiejetnosciach edytorskich. Naucz sie obslugiwac ed, ktory jest jedynym wewnatrzmudowym edytorem, lub uzywaj zewnetrznego edytora i pliki slij przez ftp. Polecam edytor emacs i ftp. Pamietaj, ze pliki mozesz tworzyc takze pod Windowsem np. w Notatniku, ale zanim wyslesz pliki na serwer musisz je konwertowac na format UNIXa.

Ponizsze komendy sa dobrze opisane w mudzie, po prostu wpisz ?<komenda>, by uzyskac pelen opis. To co ja napisalem to zwykle podsumowanie i streszczenie tego.

 load: Ladowanie obiektu do pamieci
 clone: Ladowanie i klonowanie obiektu do gry 
 destruct: Niszczenie sklonowanego obiektu 
 update: Aktualizacja obiektu 
 odnow: Odnawianie obiektu

Kompilacja i ładowanie obiektów do pamięci gamedrivera

Komenda load nakazujesz gamedriverowi, by sprobowal skompilowac i zaladowac dany plik do pamieci. Komendy tej uzywa sie zazwyczaj, by sprawdzic czy dany plik w ogole sie zaladuje. Istnieja takze obiekty, ktore nie sa przeznaczone do klonowania (np. pokoje), a dzieki load udostepniamy je dla innych obiektow.

Jezeli plik sie nie zaladuje, komunikat o bledzie laduje w dwoch miejscach: glownym /lplog oraz w logu bledow nalezacym do domeny/czarodzieja, ktory stworzyl tenze obiekt. Dla domen sciezka do ostatniego ma ksztalt /d/<Domena>/log/errors, zas dla czarodziei /d/<Domena>/<czarodziej>/log/errors.

Niestety komunikaty o bledach sa nierzadko trudne do zrozumienia. Nie moge zatem w tej materii sluzyc pomoca, bo po prostu jest ogromna ilosc roznych typow takich komunikatow, zreszta zapewne z wiekszoscia sie spotkacie :) Wiele komunikatow latwo jest zrozumiec, a z czasem kazdy koder nauczy sie rozpoznawac i zapobiegac tym ciekawszym...

Komenda load moze obslugiwac takze wieksza ilosc plikow jednoczesnie w porcjach w odstepach czasowych. Ladowanie jednakze, to raczej obciazajaca proces operacja, wiec lepiej unikac masowego ladowania plikow.

CIEKAWOSTKA:

Uzywajac ls z opcja F (tzn. ls -F) widzisz w liscie plikow i katalogow , ktore zostaly juz zaladowane do pamieci (sa one oznaczone gwiazdka). Warto zatem uzywajac komendy <alias ls ls -F> nadpisac te komende.

Kompilacja, ładowanie i klonowanie obiektów do gry

Jezeli dany obiekt zostal zaladowany do pamieci, mozna go sklonowac. Zreszta jesli potrzeba komenda clone laduje i klonuje jednoczesnie. Jesli natkniesz sie na problemy pamietaj by sprawdzic logi bledow.

Niszczenie sklonowanego obiektu

Komendy destruct uzywamy, by usunac sklonowany obiekt z pamieci. Komenda ta niszczy jedynie dany obiekt nic wiecej.

Aktualizacja załadowanego obiektu

Komendy update uzywamy w przypadku gdy w pliku zaszla zmiana i chcemy, aby gamediver ponownie go skompilowal.

Odnawianie obieku

Warto takze zwrocic uwage na komende odnow. Komenda ta laczy w sobie cztery inne – niszczy stary klon (destruct), przeladowuje obiekt na nowa wersje (update, load) i klonuje z powrotem nowa wersje obiektu (clone) w miejsce, gdzie byl stary klon. W przypadku, gdy poda sie sciezke zamiast nazwy obiektu, komenda przeladuje podany obiekt i sklonuje jego nowa wersje.

Narzędzie Tracer

Wbudowany zestaw narzedzi czarodzieja, zwany Tracerem, moze okazac sie nieodlaczny przy oddzialywaniu na wnetrze obiektu, ktory juz zaladowano do gry. Pozwala bowiem wywolywac przerozne funkcje w dowolnym obiekcie, bez wzgledu na to gdze sie znajduje, pozwala takze na wyswietlenie inwentazra obiektu, a nawet przenoszenie obiektow z roznych miejsc w inne. Warto poznac ten zestaw narzedzi doglebnie.

Niektorzy skarza sie, ze Tracer jest dosyc ciezki w uzyciu. Jest tak dlatego, bo nie chcialo im sie poczytac wiecej o Tracerze w manualu gry. Wewnetrzy manual gry jest napisany trudnym jezykiem, wiec postanowilem blizej zajac sie Tracerem.

Warto zwrocic uwage, ze kazda komenda z Tracera zaczyna sie wielka litera. Sluzy to odroznieniu od zwyklych komend, z ktorych niektore nazywaja sie tozsamo. Komendy Tracera sa dostepne jedynie dla pelnych wizardow (Praktykant i dalej).

Na poczatek przyjrzyjmy sie temu, jak tracer widzi obiekty. Podam jak odwolywac sie do danego obiektu w danej sytuacji.

• nazwa

W ten sposob mozna odwolywac sie do obiektow znajdujacych sie w ekwipunku lub w twoim srodowisku (np. na tej samej lokacji). Uwaga! Wiele obiektow moze dzielic te same nazwy (np. ‘czlowiek’, ‘zbroja’, ‘miecz’). (uzycie np. In czlowiek ...)

• "opis"

Tu uzywamy krotkiego opisu obiektu, znajdujacego sie w ekwipunku lub w tym samym srodowisku (np. tej samej lokacji). Zazwyczaj podaje sie dokladniejszy opis, nie tylko sama nazwe. (uzycie np. Destruct "wysoki elf")

• sciezka

Tu podajemy pelna sciezke Jezeli chcesz operowac na okreslonym pojedynczym obiekcie, dodajesz numer klonowania. Np. sama sciezka ~Ansalon/guild/society/obj/nametag, albo ~Ansalon/guild/society/obj/nametag#22144 dla okreslonego obiektu.

• @nazwa

W tym przypadku operujemy na istocie zywej (potworze NPC), ktora znajduje sie gdziekolwiek w grze. Zauwazmy, ze tracer znajdzie nazwe ustawiona poprzez wywolanie efunkcji set_living_name() (opisana wczesniej w manualu), a nie przez nazwe okreslona przez set_name(), czy tez ustaw_nazwe(), ustaw_imie(), itp. Istota zywa (gracz) jest automatycznie dodawana do listy livingow.

• *nazwa

This specifies the name of a player, and nothing else.

• here

W tym przypadku dzialamy na srodowisku, w ktorym sie znalezlismy, np. na pokoju gdzie stoimy.

• me

Tutaj natomiast na samym sobie, swoim obiekcie gracza.

• #numer

Tutaj okreslamy numer obiektu. Jezeli np. wiesz, ze miecz, ktory masz przy sobie jest trzecim obiektem, wowczas odwolanie ma ksztalt #3. Nalezy pamietac, ze kolejnosc obiektow moze zmienic sie bez ostrzezenia, wowczas obiekt #3 bedzie zupelnie innym niz chcielismy. Zamiast tego nalezy uzywac zmiennych tracera (opisanych przy komendzie Set), by problemu uniknac..

• $zmienna

Okresla zawartosc zmiennej tracera (opisane przy komendzie Set). Obiekty czesto istnieja w roznych rodzajach srodowisk. Czasem w tym samym miejscu co inne, czasem wewnatrz innych, itp. W celu okreslenia relacji typu „drugi obiekt wewnatrz misia w tym samym pokoju, w ktorym stoje” podaje sie liste specyfikacji obiektow rozdzielona dwukropkiem (:). Srodowisko danego obiektu jest wowczas okreslone przez :^.

Przykladowo, poprzedni opis o misiu wygladalby tak:^mis:#2. To naprawde nie jest az tak skomplikowane jak wyglada.

Inny przyklad: „miecz w torbie trzymanej przez Adama”: *adam:torba:miecz.

At: Wykonanie polecenia w srodowisku gracza
Call: Wywolanie funkcji obiektu/na obiekcie
Cat: Podglad pliku zwiazanego z danym obiektem 
Clean: Niszczenie wszystkich nie zywych przedmioto w obiekcie 
Destruct: Niszczenie okreslonego obiektu
Dump: Wyswietlenie przeroznych informacji o obiekcie
Ed: Edycja pliku zwiazanego z obiektem
Goto: Wejscie do srodowiska obiektu 
In: Wykonanie komendy w innym obiekcie
Inventory: Wyswietlenie inwentarza obiektu
Items: Przegladanie itemow zawartych w danym obiekcie/srodowisku
Light: Wyswietlenie listy obiektow danego srodowiska
More: Przegladanie pliku zwiazanego z obiektem w porcjach
Move: Przemieszczenie obiektu do miejsca docelowego
Set: Ustawienie zmiennej tracera
Tail: Przegladanie porcjami pliku zwiazanego z obiektem, od konca

Wykonywanie komend w środowisku gracza

Komenda ta tak naprawde przenosi wywolujacego do srodowiska w ktorym przebywa dany gracz w celu wykonania danej komendy. Przeniesienie to odbywa sie w sposob bezwzgledny, tzn. zadne sprawdzenia mozliwosci przeniesienia nie sa sprawdzane.

Skladnia: At <imie_gracza_w_mianowniku> <polecenie>

Zazwyczaj istnieja lepsze sposoby do osiagniecia podobnego celu, jednak dla pewnych kwestii komenda At okazuje sie nieodzowna. Dobrym na to przykladem jest sytuacja, gdy chcemy spojrzec na pokoj, w ktorym znajduje sie dany gracz, np. Adam. W tym celu wykonujemy:

At adam sp

UWAGA! Warto zachowac ostroznosc przy wykonywaniu tego wobec smiertelnikow, istnieja sytuacje, w ktorych wywolujacy moze okazac sie widoczny dla gracza. Warto przeto uzyc ‘invis’ nim wywolamy podobna komende.

Wywoływanie funkcji na obiekcie

Komenda Call jest szczegolnie uzyteczna. Dzieki niej mozesz wyolywac funckje na obiekcie podajac dowolne parametry [w praktyce jednak nie kazdy typ argumentu da sie ta droga bezproblemowo przekazac].

Skladnia: Call <dany_obiekt> arg1%%arg2%%...

Przykladowo, aby ustawic wlasnosc OBJ_I_VOLUME na 55 w drugim obiekcie z ekwipunku Adama wykonujemy:

Call *adam:#2 add_prop _obj_i_volume%%55

Warto zauwazyc, ze odwolano sie bezposrednio do stringu "_obj_i_volume", albowiem jest on dopiero na poziomie <stdproperties.h> definiowany jako zamiennik dla OBJ_I_VOLUME, ale tego Call niestety nie uwzglednia.

Przegladanie zawartości pliku związanego z danym obiektem

Komenda Cat, wspolnie z More jest dosyc ciekawa i czesto uzyteczna komenda. Zwraca ona zrodlo pliku zwiazanego z danym obiektem, o ile mamy prawa odczytu dla niego. Oczywiscie Cat zwraca jedynie 100 pierwszych linijek kodu, by przejrzec calosc nalezy uzyc stronnicowania [zobacz komende More].

Skladnia: Cat <dany_obiekt>

Zniszczenie wszystkich nieinteraktywnych zawartych w obiekcie docelowym

Clear jest uzyteczna komenda dla czyszczenia zawartosci danego obiektu. Czesto uzywa sie jej, gdy np. mamy duzo obiektow w danej lokacji i chcemy szybkim ruchem je usunac albo gdy nierozwazny czarodziej sklonuje obiekt, ktorego dzialania nie do konca przewidzial i przykladowo sparalizuje go on, wowczas dowolny inny czarodziej moze go szybko uratowac uzywajac tej komendy ;)

Skladnia: Clean <dany_obiekt>

UWAGA! Wszystkie nieinteraktywne obiekty, jak np przedmioty i npce, ulegna zniszczeniu.

Zniszczenie określonego obiektu

W celu zniszczenia konkretnego obiektu, uzywamy komendy Destruct. Czasami np. gdy funkcja leave_inv() obiektu zawiera wadliwy kod, dany obiekt moze nie ulec zniszczeniu od razu. Nalezy wtedy uzyc opcji -D, czyli np. Destruct -D miecz, by wymusic usuniecie danego obiektu.

Skladnia: Destruct [-D] <dany_obiekt>

UWAGA! Nalezy unikac uzywania opcji -D i stosowac ja wylacznie wtedy, gdy jest to konieczne. Zaleznie od wersji mudliba moze wystepowac opcja -f, dzialajac tozsamo jak -D.

Pobieranie szczegółowych informacji o danym obiekcie

Komendy Dump uzywamy by pobrac specyficzne informacje z danego obiektu. Wybor jest dosyc duzy.

Skladnia: Dump <dany_obiekt> <jakie_informacje_chcemy>

Mozliwe informacje:

• <nic>

Komenda Dump <dany_obiekt> pobiera nazwe, sciezke, uid tworcy oraz euid docelowego obiektu.

• <zmienna>

O ile zmienna nie jest rownoznaczna z jednym z ponizej opisanych parametrow, to jest interpretowana jako zmienna w badanym obiekcie. Komenda zwraca nam tedy wartosc tejze zmiennej.

UWAGA! Jest to naprawde uzyteczny sposob uzycia tej komendy. Przydac sie moze przy roznego rodzaju debugowaniu kodu. Nie trzeba bowiem ingerowac w kod obiektu by dowiedziec sie jaka wartosc ma zmienna w danym obiekcie. Oczywiscie wciaz sporo jest przypadkow, w ktorych to nie wystarczy i trzeba uzyc wlasnych funkcji debugu.

• alarms

Zwraca wszystkie biezace alarmy „biegajace po” danym obiekcie.

• cpu

Parametr ten zwraca ile czasu procesora zostalo zuzyte przez badany obiekt. Dziala wylacznie gdy wlaczono PROFILE_OBJS w config.h drivera. Opcji tej uzywa sie generalnie przy rozwijaniu mudliba lub tez badaniu jego wydajnosci.

• flags

Zwraca wszystkie pochodzace z drivera flagi zwiazane z badanym obiektem, wraz z innymi informacjami o stanie obiektu. Informacje te sa uzyteczne jedynie dla osob pracujacych nad udoskonaleniem drivera.

• functions

Zwraca wszystkie funkcje zdefiniowane w danym obiekcie.

UWAGA! Zwraca jedynie funkcje z obiektu polozonego najwyzej w hierarchii dziedziczenia. Tzn. nie podaje funkcji, ktore obiekt nabyl z innego dziedziczonego obiektu.

• info

Parametr ten zwraca pewne podstawowe zwiazane z driverem informacje przyporzadkowane do danego obiektu. Ponownie, informacje te sa uzyteczne jedynie dla osob pracujacych nad driverem.

• inherits

Uzyteczny parametr zwracajacy liste obiektow, po ktorych dany obiekt dziedziczy.

• inv | inventory

Zwraca inwentarz/ekwipunek/zawartosc obiektu badanego wraz z numerami odpowiadajacymi zawartym tam obiektom, ktorych mozna uzyc przy dalszych wywolaniach, np. funkcji na mieczu, ktory jest w ekwipunku gracza X. [patrz: opis odwolan do obiektow w 2.5]

W niektorych wersjach mudliba wystepuje jako osobna komenda tracera Inventory [I]

• items

Zwraca liste wszystkich pseudo-przedmiotow, np. takich, ktore jedynie dodaja opis, lub komendy, ktore dodano do badanego obiektu.

• light

Ten parametr zwraca liste stanow swiatla dla danego obiektu i informuje o efektach dla obiektow w nim zawartych. Poda zatem obecny stan oswietlenia i czy obiekt generuje lub pobiera swiatlo.

• profile

Dziala wylacznio gdy skompilowany driver ma wlaczona flage PROFILE_FUNS. Zwraca wszystkie zapisane informacje profilowania powiazanych z danym obiektem. Uzywane glownie przy pracy nad optymalizacja i rozszerzeniem drivera.

• props | properties

Zwraca wszystkie wlasnosci [propy] danego obiektu.

• shadows

Zwraca wszystkie shadowy powiazane z danym obiektem.

• vars | variables

Zwraca liste wszystkich zmiennych danego obiektu.

• wizinfo

Zwraca specjalna informacje zapisano w obiekcie poprzez wlasnosc OBJ_S_WIZINFO. Glownie zawiera wazne informacje dla innych czarodziei, jak zajmowac sie danym obiektem, czego z nim robic sie nie powinno, itd.

UWAGA! To czy taka informacja znajdzie sie w obiekcie zalezy wylacznie od kreatora tego obiektu i jego zastosowania.

Ed(ycja) pliku powiązanego z obiektem

Komenda Ed uruchamia (dość toporny) edytor ed z otwartym plikiem, do ktorego odwołuje sie badany obiekt.

Skladnia: Ed <dany_obiekt>

Przenoszenie istoty żywej/obiektu do danego środowiska

Komenda Move pozwala na przeniesienie dowolnego obiektu do innego okreslonego srodowiska. W przypadku przenoszenia istoty zywej uzyte zostanie odwolanie do funkcji move_living() z flaga teleportacji, w przypadku niepowodzenie przy przenoszeniu istoty zywej podejmowana jest proba przez odwolanie do funkcji move(). Dla obiektow zawsze uzywana jast funkcja move(). Gdy uzyjemy opcji -f, wymuszajacej przeniesienie, wowczas zawsze wykonywane jest move( ,1).

Skladnia: Move [-f] <dany_obiekt> [<obiekt_docelowy>]

/ w [] podano parametry opcjonalne /

Wykonywanie komendy wewnątrz innego obiektu

Komenda In dziala podobnie do komendy At, z ta roznice, ze jej dzialanie odbywa sie w inwentarzu dowolnego obiektu, gdzie to wykonujacy jest na chwile przenoszony. Stosowac z rozwaga i wylacznie gdy to konieczne. Nalezy zwrocic uwage, ze wiekszosc obiektow nie jest przeznaczonych do przyjmowania obiektow gracza wewnatrz siebie.

Skladnia: In <dany_obiekt> <komenda>

More – przeglądanie pliku powiązanego z obiektem

More to bardzo uzyteczna komenda, stanowiaca swoiste rozszerzenie Cat w tryb stronnicowany. Zezwala na wygodne przejrzenie kodu danego obiektu, ktory dzielony jest w zaleznosci od potrzeb, na kilka stron.

Skladnia: More <dany obiekt>

Set – ustawianie zmiennej narzędziowej tracera

W tym miejscu odwolam sie do tego co napisano wczesniej. Jednym z najwiekszych niebezpieczenst z pojawiajacych sie przy stosowaniu narzedzi tracera jest zmiana liczby porzadkujacej, okreslajacej pozycje obiektu na ktorym dzialamy, w inwentarzu jego srodowiska.

Skladnia: Set $<zmienna> <dany_obiekt>

Zalozmy, by ulatwic omowienie problemu, ze chcemy odnowic stworzony przez nas miecz, znajdujacy sie w ekwipunku gracza Adama. Przyjmijmy, ze miecz ten zawieral w poprzedniej wersji istotne wady i chcemy go zastapic nowa wersja, ale tak by Adam w ogole sie nie spostrzegl. Aby znalezc dokladna liczbe okreslajaca pozycje miecza w ekwipunku Adama uzywamy Dump *adam inv [lub I *adam], niech bedzie to liczba 5. Nastepnie wykonujemy komende Destruct *adam:#5. W sytuacji gdy Adam w miedzyczasie odlozyl miecz, lub np. schowal go do plecaka, i zamiast miecza zniszczylismy jego cenne 3000 mithrylowych monet! To na pewno by mu sie nie spodobalo :)

Aby uniknac takich problemow nalezy zastosowac nastepujaca czynnosc. Pobieramy odwolanie do obiektu, jak w przykladzie powyzej i zapisujemy to w zmiennej. W przykladzie mamy: miecz posiada w chwili obecnej numer 5 w ekwipunku Adama, wykonujemy przeto Set $miecz *adam:#5. Po tym jak nastapia przetasowania w ekwipunku Adama tracer poinformuje nas, ze zmienna sword wskazuje teraz na stos mithrylowych monet. Zalozmy, ze miecz spadl na pozycje 4. Ustawiamy Set $miecz *adam:#4 i na powrot zmienna wskazuje wlasciwy obiekt. Wykonujemy Destruct $miecz i miecza juz nie ma. Prawda, ze proste? Teraz wystarczy go podmienic nowym.

Operacje odnowienia tego miecza, daloby sie wykonac na wiele innych, latwiejszych i na pewno mniej ryzykownych sposobow, powyzszy przyklad mial za zadanie jedynie zilustrowac mechanizm dzialania komendy Set.

Mozna ustawic dowolna liczbe zmiennych, nalezy jednak pamietac, ze po wylowaniu sie przepadna one. Podobnie, gdy obiekt ulegnie zniszczeniu, ten sam los spotka wskazujaca nan zmienna.

Set bez zadnych argumentow zwroci nam pelna liste ustawionych przez nas zmiennych.

Ciekawostka jest fakt, ze ostatni obiekt na ktorym wywolano komende tracera zostaje przypisany pod zmienna $. Czyli po wywolaniu na obiekcie jakiejs funkcji tracera, nastepna mozna wywolac juz na zmiennej $ (<Komenda_tracera> $ <opcje>), a zostanie ona wywolana na tym samym obiekcie.

Aktualizacja, przeładowanie, sklonowanie i zastąpienie danego obiektu nową wersją

Komenda Replace moze okazac sie bardzo uzyteczna. [Nie zostala uwzgledniona wsrod narzedzi tracera w mudlibie CDpl.01.00, porownaj ?odnow]

Przy jej uzyciu mozesz zaktualizowac obiekt nadrzedny danego obiektu, ponownie sklonowac nowa wersja i nadpisac ja na stara, ktora ulegnie degradacji.

Jesli nowa wersja nie da sie przeniesc w sposob bezposredni, kolejna proba przeniesienia nastepuje na zasadzie wymuszenia.

Jesli wystapi blad krytyczny podczas odnawiania, proces zostanie przerwany, a stara wersja nie zostanie nadpisana.

Skladnia: Reload <dany obiekt>

Tail – przeglądanie powiązanego z obiektem pliku od końca

Komenda Tail dziala podobnie jak Cat i More, z ta roznica, ze wyswietla ostatnie linijki kodu.

Zaawansowany LPC i Mudlib

W rozdziale tym zajmiemy sie nieco bardziej zaawansowanymi sprawami dotyczacymi LPC. Musisz naprawde zrozumiec podstawy LPC, ktore wylozylem w poprzednich rozdzialach, zeby moc przyswoic sobie to, co tu opisuje.

Nie miej zadnych oporow przed przegladaniem poprzednich rozdzialow w razie potrzeby, czytajac ten tekst.

Funkcja jako typ danych, część 3

Typ funkcyjny (function) jako taki nie byl dotychczas szczegolowo omawiany w tym podreczniku, choc czasami uzywany. Jednak, ze wzgledu na jego wage nalezy go omowic. Dokladna znajomosc jego wlasnosci pozwoli ci stworzy czesto bardzo skomplikowane i zlozone, lecz jednoczesnie efktywne i optymalne partie kodu. Warto wiedziec, ze wszystkie funkcje ktore zwykly przyjmowac nazwy funckji jako stringi, w chwili obecnej sa zdolne do pobrania wskaznika do danej funkcji jako argumentu, co jest efektywniejsze.

Podstawowe informacje o typie funkcyjnym

Dostep do funkcji mozna uzyskac przez wskazniki funkcji. Jak pokazano wczesniej, kazda wywolanie funkcji sprowadza sie do wskaznika funkcji powiazanego z lista argumentow. Rozpatrzmy to na prostym przykladzie.

void moja_funkcja(string str, int value) { write("Jako string podano: '" + str + "', zas jako liczbe: " + value + ".\n"); return; }

Wywolanie funkcji nastepuje przez odwolanie sie do niej za posrednictwem jej nazwy i nastepujacych po niej argumentow podanych w nawiasie.

   Przykladowo:
   moja_funkcja("smurf", 1000);

Teraz rozszerzymy to zgodnie z pomyslem typu funkcyjnego, gdzie mozna pobrac adres funkcji i nastepnie przypisac innej zmiennej.

Przykladowo:

   function nowa_funkcja;

   nowa_funkcja = moja_funkcja;       // lub rownowaznie
   nowa_funkcja = &moja_funkcja();

   moja_funkcja("smurf", 1000);   // lub rownowaznie
   nowa_funkcja("smurf", 1000);

Zwrocmy uwage, ze nim zmiennej nowa_funkcja przypisano poprawna wartosc, nie odwolywala sie ona do zadnej funkcji. Uzycie jej w takim przypadku doprowadzilo by do bledu run-time.

Okrojona lista argumentów

W poprzednim rozdziale moglismy zaobserwowac, ze mozliwe jest przypisanie odwolania do jednej funkcji zmiennej o innej nazwie. Innym przydatnym zastosowaniem moze okazac sie mozliwosc takiego przypisania, ze niektore argumenty dla oryginalnej funkcji jest traktowana jako stala, pozostawiajac reszte jako zmienne. Zilustrujemy to przykladem:

   void
   tell_player(object player, string mess)
   {
       player->catch_msg(mess + "\n");
   }

   void
   moja_funkcja()
   {
       function mod_tell;

       mod_tell = &tell_player(this_player(), );

       mod_tell("Witaj!"); // Rownowazne wzgledem

       tell_player(this_player(), "Witaj!");
   }

Dziala to dobrze, bez wzgledu na ilosc argumentow. Pozostale argumenty zostana wypelnione od lewej do prawej.

Przykladowo biorac funkcje o naglowku void func(int a, int b, int c, int d, int e) przy zmiennej okreslonej nastepujaco function moja_funkcja = func(1, , 3, 4,); otrzymamy, ze wywolanie moja_funkcja(100, 101); dziala tak samo jak wywolanie func(1, 100, 3, 4, 101);

Złożenia funkcji i kompleksowe struktury

W tym miejscu wazne jest, by czytelnik poruszal sie zrecznie w plaszczyznach problemow omowionych w poprzednich rozdzialach. Pojawia sie pytanie: ‘Co mozna umiescic w wywolanie funkcji tego typu?’.

Odpowiedz brzmi: ‘Prawie wszystko’.

Jest to oczywiscie zalezne od umiejetnosci wlasnych i gibkosci poruszania sie w ramach kodu.

Wiele osob miewa problemy ze zrozumieniem operatorow. Wsrod nich mamy: +, -, *, /, %, &, |, ^, >>, <<, <, >, <=, >=, ==, !=, [].

Dosyc czesto programista chce wykonac jedna operacje i jej wynik przeslac bezposrednio jako argument dla innej.

Typ funkcyjny obsluguje superpozycje [zlozenie] funkcji poprzez operator @.

Dziala on jak matematyczne zlozenie, od prawej do lewej! Podobnie jak operator.

Oto przyklad, ktory, miejmy nadzieje, rozjasni wszystko:

Niech pewna tablica zawiera imiona pewnych graczy:

                 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:

               string *
               func(string *arr)
               {
                   int i, sz;
                   string *result = ({});
                   for (i = 0, sz = len(arr); i < sz; i++)
                   {
                       if (strlen(arr[i]) > 5)
                       result += ({ arr[i] })
                   }
               return result;
               }

Oczywiscie, mozna uzyc efunkcji filter:

               int
               filterfunc(string item)
               {
                   return strlen(item);
               }
               
               string *
               func(string *arr)
               {
                   return filter(arr, filter_func);
               }

Ale w takim przypadku musze pisac osobna funkcje filtrujaca. Na szczescie mozna pojsc jeszcze dalej, do efektownego zapisu jednolinijkowego !

               // ... tu mamy zdefiniowana tablice arr
               
               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).

Teraz nieco skomplikujemy sytuacje. Chcemy pojsc dalej i pobrac z tablicy wylacznie Smiertelnikow [ktorych imiona skladaja sie z conajwyzej pieciu znakow.]

Oczywiscie jest to proste i wyglada nastepujaco:

               // ... tu mamy zdefiniowana tablice arr

               result = filter(filter(arr, &operator(<)(5) @ strlen), 
                       &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.

Pojdzmy dalej. Jak myslisz co sie stanie gdy wykonasz nastepujace polecenie? Co pojawi sie na ekranie?

               exec return implode(sort_array(map(filter(users(), sizeof @ 
                           &filter(, &call_other(, "id", "tarcza")) @ 
                           deep_inventory)->query_real_name(), capitalize)), ", ");

Na pewno wiekszosci czytelnikow wydaje sie to prosciutkie.

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.

Innymi slowy: otrzymuje spis osob, ktore maja 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.

Chodzi glownie o to by juz na etapie pisania kodu przewidywac jakie beda konsekwencje jego uzycia.

3.2 Pisanie efektywnego kodu

Ten temat jest blisko powiazany z tym co powiedzialem wczesniej, ze nie bede wyjasniac jak programowac. Wycofam swe slowa – troszeczke – i opowiem o kilku sprawach co robic, albo nawet co wazniejsze, czego nie robic.

Efektywne pętle

Ten temat moze sie wydawac raczej trywialny. W koncu na ile sposobow mozna zapisac petle? Raczej na niewiele. Zacznijmy od najczestszego bledu. Zalozmy, ze mamy jakas duza tablice, nazwijmy ja ‘wielka_tab’ i zalozmy, ze chcemy ‘przeleciec’ petla przez wszystkie jej elementy. Co robisz w takiej sytuacji? „Proste!” wyjasniasz, „Oczywiscie, ze zwykla petla ‘for’!”. Pewnie... Ale jak to zapiszesz? Najczesciej ludzie robia to w ten sposob:

        int i;
    
        for (i = 0 ; i < sizeof(wielka_tab) ; i++)
        {
            // Tu robimy cos z tablica
        }

No tak... a wiec co jest zle? Jesli przejrzysz rozdzial mowiacy o dzialaniu instrukcji ‘for’, to zobaczysz, ze wykonywane sa trzy czesci w okraglych nawiasach oddzielone srednikami. Pierwsza tylko na poczatku, druga (srodkowa) za kazdym cyklem petli i trzecia rowniez za kazdym razem na koncu kazdego cyklu.

Oznacza to, ze funkcja ‘sizeof()’ zostaje wykonana za kazdym cyklem petli. Jest to raczej marnotrastwo, biorac pod uwage fakt, ze tablice rzadko zmieniaja rozmiar. Jesli by robily to czesto, bylaby to inna para kaloszy, ale jako ze nie robia... Nie. Napisz to w ten sposob:

        int i, sz;
    
        for (i = 0, sz = sizeof(wielka_tab) ; i < sz ; i++)
        {
            // Tu robimy cos z tablica.
        }

Widzisz? Zmienne ‘i’ oraz ‘sz’ tylko na poczatku dzialania petli maja przypisywane wartosci. Licznik ‘i’ zostaje ustawiony na 0, a zmiennej ‘sz’ zostaje przypisany rozmiar tablicy. Przez caly czas dzialania petli porownywane sa same zmienne, zamiast ciaglego obliczania nie zmieniajacego sie rozmiaru tablicy.

Mozesz mi wierzyc albo nie, ale to jest bardzo czesty blad, prawie kazdy go robi. Oszczednosci w moim sposobie moga sie nie wydawac tak wielkie... ale... pomnoz to razy wszystkie petle w mudzie i przez liczbe razy kiedy sa wykonywane, a otrzymasz calkiem niezla liczbe. Kosztem drugiego sposobu w porownaniu do pierwszego jest dodanie jednej zmiennej lokalnej i to jest wystarczajaco mala cena.

Pamietaj o tym problemie nie tylko w przypadku tablic, ale rowniez w mappingach lub innych ogolnych pojemnikach, zawierajacych rzeczy, przez ktore chcesz ‘przeleciec’ petla. Rozwiazanie, z wyjatkiem malych roznic w rozpoznawaniu rozmiaru pojemnika jest zawsze takie same.

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:

       // Gorna partia pliku
       
       #define GUILD_MAP ([ 0: ({ "poczatkujacy", "troche", 3, 2343, ... }), \
                    1: ({ ....                                          \
                    ... /* i dalej okolo 20 lub wiecej podobnych linijek */        \
                  ])
       
       // kodowy przyklad uzycia
       write("Masz obecnie range: " + GUILD_MAP[rank][1] + "\n");
       // 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.

Zamiast makrodefinicji o wiele efektywniej mozna to zrobic tak, uzywajac zmiennej:

       // Gorna partia pliku
       
       mapping GuildMap;
       
       create_object()
       {
           // kod
       
           GuildMap =  ([ 0: ({ "poczatkujacy", "troche", 3, 2343, ... }), \
                    1: ({ ....                                          \
                    ... /* i dalej okolo 20 lub wiecej podobnych linijek */        \
                  ]);

       }
       
       // kodowy przyklad uzycia
       write("Masz obecnie range: " + GuildMap[rank][1] + "\n");
       // dalszy kod...

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.

Wiele z tych bledow juz opisano we wczesniejszych rozdzialach, ale nie zaszkodzi powtorzyc.

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.

Przyjrzyjmy sie przykladowi obiektu gildiowego, ktory zajmuje sie czlonkami gildii. Globalna zmienna Rada, ktora jest zapisywana przez save_object() zawiera rade gildii.

       string *Rada;
       
       public string
       zwroc_rade()
       {
           return Rada;
       }

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:

       void
       moja_funkcja()
       {
           string *rada_po_moich_poprawkach;
       
           rada_po_moich_poprawkach = OBIEKT_GILDIOWY->zwroc_rade();
       
           rada_po_moich_poprawkach += ({ "olorin" }); // I dodaje Olorina do rady gildii i kazdy
       			// moze to zrobic!
       }

Jak to zatem poprawic? Wystarczy zmodyfikowac funkcje zwroc_rade, by zwracala return Rada + ({}); i wszystko bedzie w porzadku. Latwo przegapic, a jakiez to wazne!

Zapętlanie alarmów

Przyjrzyjmy sie nastepujacej funkcji:

       public void
       moje_wlasne_alarmy(int ile)
       {
           set_alarm(1.0, 1.0, moje_wlasne_alarmy(ile + 1));
           tell_object(find_player("<twoje_imie>"), "Buu! " + ile + "\n");
       }

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:

       1 sekunda:
           Buu! 0 (oryginalne wywolanie)
       2 sekunda:
           Buu! 1 (powtorzenie 1 sek 0)
           Buu! 1 (nowe od 1 sek 0)
       3 sekunda:
           Buu! 1 (powtorzenie 1 sek 0)
           Buu! 2 (powtorzenie 2 sek 1)
           Buu! 2 (powtorzenie 2 sek 1)
           Buu! 2 (nowe od 2 sek 1)
           Buu! 2 (nowe od 2 sek 1)
       4 sekunda:
           Buu! 1 (powtorzenie 1 sek 0)
           Buu! 2 (nowe od 3 sek 1)
           Buu! 2 (powtorzenie 2 sek 1)
           Buu! 2 (powtorzenie 2 sek 1)
           Buu! 3 (powtorzenie 3 sek 2)
           Buu! 3 (powtorzenie 3 sek 2)
           Buu! 3 (powtorzenie 3 sek 2)
           Buu! 3 (powtorzenie 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)
       
          ... 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. Oczywiscie na obecnym etapie rozwoju wiekszosc LPMudów jest zabezpieczona przed uzyciem partykularnie tozsamej konstrukcji.

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 ;)]

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]

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’!

       > man -k *id
       
       --- simul_efun:
       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.

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).

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. 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.

Takze tutaj mozliwe jest przeszukiwanie smanu wg podanych kryteriow [szczegoly ?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.

       > sman -k *guild*
       --- /lib/guild_support:
       create_guild_support     init_guild_support
       
       --- /secure/master:
       add_guild_master                      query_guild_type
       guild_command                         query_guild_type_int
       guild_filter_type                     query_guild_type_long_string
       guild_sort_styles                     query_guild_type_string
       load_guild_defaults                   query_guilds
       query_guild_domain                    remove_guild_master
       query_guild_is_master                 set_guild_domain
       query_guild_long_name                 set_guild_long_name
       query_guild_masters                   set_guild_phase
       query_guild_phase                     set_guild_style
       query_guild_short_name                set_guild_type
       query_guild_style                     
       
       --- /std/guild/guild_base:
       list_major_guilds                     query_guild_not_allow_join_guild
       query_guild_keep_player               query_guild_skill_name
       query_guild_leader                    query_guild_style
       query_guild_member                    
       
       --- /std/guild/guild_lay_sh:
       query_guild_incognito_lay             query_guild_tax_lay
       query_guild_leader_lay                query_guild_title_lay
       query_guild_member_lay                query_guild_trainer_lay
       query_guild_name_lay                  query_guild_type
       query_guild_not_allow_join_lay        remove_guild_lay
       query_guild_style_lay                 
       
       --- /std/guild/guild_occ_sh:
       query_guild_incognito_occ             query_guild_tax_occ
       query_guild_leader_occ                query_guild_title_occ
       query_guild_member_occ                query_guild_trainer_occ
       query_guild_name_occ                  query_guild_type
       query_guild_not_allow_join_occ        remove_guild_occ
       query_guild_style_occ                 
       
       --- /std/guild/guild_race_sh:
       query_guild_family_name               query_guild_style_race
       query_guild_incognito_race            query_guild_tax_race
       query_guild_leader_race               query_guild_title_race
       query_guild_member_race               query_guild_trainer_race
       query_guild_name_race                 query_guild_type
       query_guild_not_allow_join_race       remove_guild_race
       
       --- /std/living:
       clear_guild_stat         set_guild_pref
       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.

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 ...

Uzupelnienie by Kael

DODATEK A. Formanty odmiany polskiej

na podstawie /sys/pl.h 1) odmiana przez przypadki

PL_MIA  0 - mianownik
PL_DOP  1 - dopelniacz
PL_CEL  2 - celownik
PL_BIE  3 - biernik
PL_NAR  4 - nadrzednik
PL_MIE  5 - miejscownik

np. chcac poznac imie gracza w bierniku stosujemy

 this_player()->query_name(PL_BIE);

lub

 this_player()->query_name(3);

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_NOS_ZYW        1 - wskazuje na odmiane nieosobowa dla istoty zywej (np. kota)
PL_MESKI_NOS_NZYW       2 - wskazuje na odmiane nieosobowa dla przedmiotu (np. dlugopis)
PL_MESKI_NZYW           2 - to samo co PL_MSESKI_NOS_NZYW 

PL_ZENSKI               3 - wskazuje na odmiane zenska

PL_NIJAKI_OS            4 - wskazuje na odmiane nijaka osobowa
PL_NIJAKI_NOS           5 - wskazuje na odmiane nijaka nieosobowa

DODATEK B. Rodzaje obrażeń

W_IMPALE    rany klute
W_SLASH     rany ciete
W_BLUDGEON  obuchowe

W_NO_DT     brak obrazen
MAGIC_DT    obrazenia magiczne