Skocz do zawartości

  • 👋 Witaj na MPCForum!

    Przeglądasz forum jako gość, co oznacza, że wiele świetnych funkcji jest jeszcze przed Tobą! 😎

    • ✅ Pełny dostęp do działów i ukrytych treści
    • ✅ Możliwość pisania i odpowiadania w tematach
    • ✅ System prywatnych wiadomości
    • ✅ Zbieranie reputacji i rozwijanie swojego profilu
    • ✅ Członkostwo w jednej z największych społeczności graczy

    👉 Dołączenie zajmie Ci mniej niż minutę – a zyskasz znacznie więcej!

    Zarejestruj się teraz

Skript - Piszemy własne skrypty

PiratJaskiniowy

Przez PiratJaskiniowy
w Minecraft - Poradniki

Rekomendowane odpowiedzi

PiratJaskiniowy Odkrywca

PiratJaskiniowy

Opublikowano
Odkrywca

PiratJaskiniowy

Opublikowano

reklama
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Skript - Piszemy własne skrypty!
Autor: PiratJaskiniowy
 
Rozdział I
Instalacja pluginu, potrzebne programy, przydatne źródła.

Zacznijmy od instalacji pluginu Skript do którego to będziemy w końcu pisać skrypty.
1. Pobieramy plugin z oficjalnej strony:






http://dev.bukkit.org/bukkit-plugins/skript/

2. Pobrany plik lub archiwum(w zależności od wybranej wersji) umieszczamy w folderze /plugins/ naszego serwera.

2.1. W przypadku pobrania archiwum wypakowujemy je do folderu /plugins/

3. Uruchamiamy serwer lub(w przypadku gdy serwer jest już uruchomiony) używamy komendy /reload.
 
Gotowe! Jeśli poprawnie zainstalowaliśmy plugin w folderze /plugins/ powinien pojawić się folder /Skript/.
 
Teraz edytory. Skrypty możemy pisać w zasadzie w dowolnym edytorze tekstu, polecam jednak dwa:

1. Sublime Text 2 - http://www.sublimetext.com/ (ja korzystam z tego)

2. Notepad++ - http://notepad-plus-plus.org/

Gdy już mamy któryś z tych programów(lub jakiś inny edytor tekstu) tworzymy w nim nowy dokument.
Warto sobie ustawić kolorowanie składni na lua, lub w przypadku Notepad++ zainstalować rozszerzenie dodające kolorowanie składni specjalnie dla skryptów.

http://dev.bukkit.org/bukkit-plugins/skript/forum/misc/54386-release-notepad-udl-for-skript-updated-august-28/

Dobrze, teraz wklejamy poniższy kod do naszego dokumentu(nie przejmuj się jeśli na razie kod ten nic Ci nie mówi):

command /hello:
	trigger:
		send "Hello, %player%!" 

Jeśli wybraliśmy odpowiednie kolorowanie składni kod nabierze troszkę kolorów.
Teraz zapisujemy utworzony dokument w formacie .sk w folderze /plugins/Skript/scripts/.
Używamy komendy /sk reload scripts. Jeśli wszystko zrobiliśmy dobrze po wpisaniu komendy /hello powinna wyświetlić się nam odpowiedź.
 
Podczas tworzenia skryptów, szczególnie na początku nie będziemy zawsze pamiętali wszystkich wyrażeń, zdarzeń, zmiennych. Z pomocą przyjdzie nam oficjalna dokumentacja pluginu(w całości po angielsku):

http://njol.ch/projects/skript/doc/

Znajdują się w niej wszystkie wyrażenia, zmienne, wydarzenia, efekty i podstawowe poradniki.
Pomocne może się okazać też oficjalne forum pluginu, a szczgulnie dział Tutorials:

http://dev.bukkit.org/bukkit-plugins/skript/forum/tutorials/

Podsumowując rozdział pierwszy:
Mamy już zainstalowany plugin Skript. Wybraliśmy edytor tekstu, w którym będziemy pracować. Wiemy jak zapisać skrypt. Wiemy gdzie możemy znaleźć informacje na temat pisania skryptów.


Rozdział II
Tworzymy własną komendę. Podstawowe wyrażenia.

Schemat nowej komendy wygląda następująco:






command /komenda:
	description: Opis komendy
	usage: Jak używać komendy np /komenda
	permission: wymagane.uprawnienie
	permission message: Wiadomość jeżeli nie posiadasz uprawnienia.
	executable by: players/console/players and console
	aliases: lista aliasów komendy np. komenda1, komenda2
	trigger:
		kod który będzie wykonywała komenda 

command /komenda : - komenda to nazwa komendy np. spawn, home czy dom. argumenty zostaną omówione w dalszej części poradnika
description: Opis komendy - Opis komendy, co ona robi. W zasadzie do niczego nie jest wykorzystywany więc możemy go pominąć.
usage: /komenda - wiadomość która wyświetli się gdy źle użyjemy komendy. Ja preferuję pominąć tą linijkę i opcje obsługi błędów zaimplementować bezpośrednio w kod komendy.
permission: wymagane.uprawnienie - potrzebne uprawnienie, tą linijkę również preferuję pominąć
permission message: Nie możesz użyć tej komendy. - tą linijkę też preferuję pominąć
executable by: players/console - kto może używać komedny. domyślnie jest player and console więc jeśli nam to pasuje możemy pominąć tą linijkę
aliases: alias1, komenda3 - aliasy komendy. gdy wpiszemy któryś alias wykona się komenda do której jest przypisany np: mamy komendę /sethome i przypisujemy do niej aliasy /ustawdom oraz /homeset i nieważne którą komendę teraz wpiszemy wykona się ten sam kod
trigger: - znacznik rozpoczynający kod komendy
 
Jak pewnie zauważyliście powyższy kod ma pewne wcięcia. Tak, tworzenie wcięć(tabowanie) ma podczas pisania skryptów bardzo duże znaczenie. Jedno wcięcie tworzymy poprzez użycie klawisza tab(Nigdy poprzez kilka spacji!).
 
Dobrze pora na trochę praktyki. Napiszemy teraz naszą pierwszą komendę.
Zaczynamy od zdefiniowania komendy i jej nazwy:






command /hey:

Jak widać nasza komenda nazywa się /hey, oznacza to, że aby jej użyć musimy wpisać na czacie /hey.
Linijka jest zakończona dwukropkiem oznacza to, że kod poniżej będzie jej dotyczył oraz, że będzie wcięty o jeden tab.
Jak wspomniałem pominiemy klika linijek, które zaimplementujemy w późniejszym kodzie.
Dodajemy alias do naszej komendy, niech będzie to czesc oraz hello:

command /hey:
	aliases: czesc, hello

Jak wyżej wspomniałem pojawiło się pierwsze wcięcie.
Teraz sprawimy aby gdy użyjemy naszą komendę serwer nam odpowiedział na powitanie:

command /hey:
	aliases: czesc, hello
	trigger:
		send "Hej, %player%!" 

Dodaliśmy linijkę trigger: zakończoną na : więc dalszy kod jeden tab dalej. Wyrażenie send "" domyślnie wysyła wiadomość do podmiotu aktywującego dane zdarzenie w tym wypadku używającego naszej komendy. W cudzysłowach mamy wiadomość, możemy jednak zauważyć w niej pierwszą zmienną pierwotną(czyli istniejącą cały czas, nie stworzoną przez nas) %player%, wyświetla ona wyświetlaną nazwę gracza.
Załóżmy, że mamy nick Skrypter gdy użyjemy komendy /hello wyświetli się nam wiadomość Hej, Skrypter!.
Chcemy teraz sprawić aby tylko gracz posiadający uprawnienie powiedz.hey mógł używać naszej komendy:

command /hey:
	aliases: czesc, hello
	trigger:
		player has permission "powiedz.hey":
			send "Hej, %player%!"
			stop
		send "Nie mozesz rozmawiac z serwerem!" 

Dodaliśmy linijkę player has permission "powiedz.hey": zakończoną dwukropkiem więc przesuwamy się o jeden tab. Linijka ta pozwala dalej "przejść" tylko jeśli gracz posiada uprawnienie powiedz.hey. Wyrażenie stop zatrzymuje komendę czyli jeśli gracz posiada nasze uprawnienie wyświetli mu się wiadomość Hej, gracz! i komenda się zatrzyma. Jeśli natomiast gracz nie będzie posiadał uprawnienia komenda ominie cały kod należący do linijki żądającej uprawnienia i przejdzie dalej gdzie mamy wiadomość Nie mozesz rozmawiac z serwerm!. Więc gdy gracz nie będzie posiadał naszego uprawnienia wyświetli mu się ostatnia wiadomość.
 
Teraz zajmiemy się argumentami. Stworzymy komendę, która będzie zapisywała do pliku kilka informacji oraz wysyłała je do wybranego gracza.
Zaczynamy od przygotowania szkieletu komendy:

command /zglos:
	trigger:
		send "to dziala!"

Chcemy aby nasza komenda wyglądała tak /zglos <nick> <treść zgłoszenia>.
Dodajemy więc w definicji(w linijce definiującej nazwę komendy) komendy dwa argumenty, jeden ma być nickiem, drugi tekstem:

command /zglos [<player>] [<text>]:
	trigger:
		send "to dziala!" 

Dodaliśmy 2 argumenty. Typem pierwszego argumentu jest player, czyli gracz, drugiego text, czyli zwykły tekst.
Do konkretnego argumentu odwołujemy się za pomocą wyrażenia arg 1, arg 2, 3 itd.
Czy dany argument został wpisany, sprawdzamy za pomocą instrukcji warunkowej(tak jak z uprawnieniami):

command /zglos [<player>] [<text>]:
	trigger:
		arg 1 is set:
			arg 2 is set:
				send "%arg 1%: %arg 2%"
				stop
			send "Podaj tresc zgloszenia."
			stop
		send "Kogo chcesz zglosic? /zglos <nick> <tresc>"

arg 1 is set: sprawdza czy argument nr 1 został podany jeśli tak przepuszcza wcięcie dalej, jeśli nie przechodzi do następnej linii na tym samym poziomie(wcięcia) czyli send "Kogo chcesz zglosic? /zglos <nick> <tresc>"
arg 2 is set: tak jak wyżej tylko sprawdza argument nr 2 i jeśli warunek nie jest spełniony przenosi do linii send "Podaj tresc zgloszenia."
send "%arg 1%: %arg 2%" wysyła wiadomość o następującej treści argument nr 1: argument nr 2, czyli aby wyświetlić dany argument musimy otoczyć go znakami procent np. %arg 3%
Mamy już obsługę błędów, teraz zajmiemy się kodem zapisującym zgłoszenie do pliku i wysyłającym powiadomienie do zgłoszonego gracza, że został przez kogoś zgłoszony:






command /zglos [<player>] [<text>]:
	trigger:
		arg 1 is set:
			arg 2 is set:
				send "Zostales zgloszony przez %player%" to arg 1
				log "[Zgłoszenie][%arg 1%][przez:%player%] %arg 2%" to "zgloszenia"
				stop
			send "Podaj tresc zgloszenia."
			stop
		send "Kogo chcesz zglosic? /zglos <nick> <tresc>"

send "Zostales zgloszony przez %player%" to arg 1 przesyła wiadomość do gracza podanego w argumencie nr 1, użyliśmy znowu pierwotnej zmiennej %player%
log "[Zgłoszenie][%arg 1%][przez:%player%] %arg 2%" to "zgloszenia" ta linia odpowiada za zapisanie wiadomości do pliku w folderze /plugins/Script/logs/ w naszym przypadku do pliku zgloszenia.txt
Załóżmy(nasz nick to Skrypter), że użyliśmy naszej komendy w następującej postaci /zglos PiratJaskiniowy Uzywa x-raya. wiadomość zapisana do pliku będzie wtedy wyglądać tak:
[data i godzina][Zgłoszenie][PiratJaskiniowy][przez:Skrypter] Uzywa x-raya.
Zamiast data i godzina będzie dokładny czas użycia komendy.
Graczowi o nicku PiratJaskiniowy wyświetli się komunikat: Zostales zgloszony przez Skrypter
 
Sprawdź się:
Napisz komendę, która będzie wysyłała wiadomość do konkretnego gracza i wymagała uprawnienia wyslij.msg.
Szkic komendy: /pw <nick> <treść>
Aliasy: msg, pm, szept
Wiadomość gdy brak uprawnienia: Nie mozesz pisac prywatnych wiadomosci. :(

Najpierw spróbuj zrobić to sam.

 






command /pw [<player>] [<text>]:
	aliases: msg, pm, szept
	trigger:
		player has permission "wyslij.msg":
			arg 1 is set:
				arg 2 is set:
					send "%player%> %arg 2%" to arg 1
					stop
				send "Co chcesz napisac do %arg 1%? /pw %arg 1% <tresc wiadomosci>"
				stop
			send "Do kogo czchesz napisac? /pw <nick> <tresc wiadomosci>"
			stop
		send "Nie mozesz pisac prywatnych wiadomosci. :(" 

 

 


 
Podsumowując rozdział drugi:
Potrafimy: tworzyć proste komendy, sprawdzać czy gracz posiada uprawnienia oraz wypełnienie argumentów, wyświetlać argument, zapisywać tekst do pliku, wyświetlać wiadomość na czacie. Rozumiemy ideę tabowania(tworzenia wcięć) w kodzie skryptów.


 
17.11.2014: Skoro ten temat tutaj nadal istnieje, a nawet ktoś jeszcze do niego zagląda to wstawię tu jeszcze 5 poradników, które popełniłem na innym forum:
[skQuery] Lambdy - lambdy i predykaty

W tym poradniku...
dowiesz się co to są lambdy, jak się dzielą i dlaczego są takie użyteczne.
 
Przedstawienie
Czym są te tajemnicze Lambdy? Lambdy to nowe elementy wspaniałego dodatku jakim jest skQuery. Pozwalają zawrzeć więcej kodu w jednej linii i tworzyć bardziej skomplikowane skrypty.
Dokładniej lambdy to dwa nowe typy, które pozwalają wsadzić więcej kodu w twój kod :):
- lambdy (lambdas), które zawierają efekty
- predykaty (predicates), które zawierają warunki (conditions)
Można łączyć wiele lambd lub predykatów ze sobą ale między sobą.
(lambda z lambdą: tak, predykat z predykatem: tak, lambda z predykatem: nie)

Lambdy

[%efekt%]
[%efekt%]->[%efekt%]
// np.
[send "lambdy!" to player]
[send "lambdy!" to player]->[send "sa fajne!"]
[send "lambdy!" to player]->[send "sa fajne!"]->[give diamond named "lambda" to player]

Predykaty

[%warunek%]
[%warunek%]->[%warunek%]
// np.
[player has diamond named "lambda"]
[player has diamond named "lambda"]->[player is op]
[player has diamond named "lambda"]->[player is op]->[name of player is "pirat"]

 
Użycie
Z przedstawionych wyżej elementów można aktualnie skorzystać na cztery sposoby.
Autorzy dodatków do Skript mogą z nich skorzystać i umożliwić korzystanie w tworzonych przez nich elementach z naszych kochanych lambd i predykatów.

Bezpośrednio
Pierwszym sposobem wykorzystania lambd jest użycie ich bezpośrednio za pomocą efektu do i wyrażenia check.

// efekt "do" dla lambd
do %lambda/y%
// np.
do [send "lambdy!" to player]->[send "sa fajne!"]->[give diamond named "lambda" to player]
// zadziala tak samo jak:
send "lambdy!" to player
send "sa fajne!"
give diamond named "lambda" to player


// wyrazenie "check" dla predykatow 
check[ed] %predykat/y%
// np.
check [player has diamond named "lambda"]->[player is op]->[name of player is "pirat"]:
    # kod
// zadziala tak samo jak:
if player has diamond named "lambda":
    if player is op:
        if name of player is "pirat":
            # kod

Wyrażenie "where"
Następną możliwością użycia predykatów jest wyrażenie where, dzięki któremu możemy zapętlić tylko obiekty spełniające dane warunki zamiast zapętlać wszystkie obiekty i dopiero w zapętleni sprawdzać ich cechy.

%obiekty% where %predykat/y%
// zeby w predykacie odwolac sie do obiektu trzeba skorzystac z wyrazenia:
%type% input
// np.
loop all players where [player input has permission "jestem.fajny"]->[player input has diamond named "lambda"]:
    # kod
// zadziala tak samo jak:
loop all players:
    loop-player has permission "jestem.fajny"
    loop-player has diamond named "lambda"
    # kod

Podczas formatowania ekwipunku
Gdy formatujemy slot ekwipunku tak aby po kliknięciu wykonać jakąś akcję, teraz zamiast komendy możemy użyć też lambdy co w połączeniu z funkcjami daje nam naprawdę potężne możliwości.

format slot %number% of %players% with %item stack% to close then run %lambda%
format slot %number% of %players% with %item stack% to run %lambda%
// np.
format slot 1 of player with cookie named "Ciastko" with lore "kliknij mnie!" to run [broadcast "%player% kliknal w ciastko!"]
format slot 1 of player with cookie named "Ciastko" with lore "kliknij mnie!" to run [access "funkcja"]

Taki krótki poradnik, może się komuś przyda.

Pirat

 


[skQuery] Własne efekty i wyrażenia

Tworzenie dodatku dla Skript w Skript?

Wielu skrypterów używało zmiennych i niestandardowych komend aby tworzyć skomplikowane i łatwo rozszerzalne skrypty. Niestety, dla wielu korzystanie z komend jest niewygodne i uciążliwe. Autorzy kilku dodatków (w tym skQuery, WildSkript, a nawet samego Skript) próbowali (i w większości im się to nie udało) wprowadzić system, który mógłby zastąpić korzystanie z komend zachowując piękno składni Skript. Dzięki wprowadzeniu niestandardowych wyrażeń i efektów możesz stworzyć swój mini-dodatek do Skript bez jakiejkolwiek wiedzy na temat Javy.
 
Krok 1: Tworzenie pliku .skq
Pierwszy krok na drodze do stworzenie nowych efektów i wyrażeń polega na stworzeniu w folderze /scripts/ pliku z rozszerzeniem .skq. Jeśli nazwę pliku zaczniesz od - nie zostanie on, tak jak w przypadku zwykłego skryptu, załadowany.
 
Dodaj jedną lub więcej poniższych linii kodu do utworzonego pliku:
 
Efekty
Wszystkie elementy są formatowane tak jak to można odczytać z oficjalnej dokumentacji, co oznacza, że możesz użyć %<typ>% wewnątrz składni aby skorzystać z parametrów.
 
declare effect "<składnia Twojego efektu>"
 
Wyrażenia
declare expression "<składnia Twojego wyrażenia>" as "<typ wartości, którą zwraca Twoje wyrażenie>"
 
declare loopable expression "<sładnia>" as "<typ>"
 
declare property "<składnia>" as "<typ>" for "<typ obiektu, dla którego jest ta właściwość>"
 
Komentarze
Każda linia zaczynająca się -- będzie odczytana jako komentarz i zignorowana.
 
Plik example.sqk, do którego będę się niżej odwoływał zawiera następujący kod: 
 

-- Test 1.0
declare effect "my custom effect"
declare expression "answer to life" as "number"
declare loopable expression "cool people" as "text"
declare property "%number% decrementation" as "number" for "number"
 

Należy także zwrócić uwgaę, że gdy uruchomisz swój serwer, plik .skq zostanie deaktywwany (w nazwie zostanie dodany -) i w folderze /scripts/ znajdzejsz nowy plik .skqc. Jeśli nie udostępniasz źródła, NIGDY NIE UDOSTĘPNIAJ PLIKU .SQK. Jeśli chcesz zmienić zawartość pliku .skq musisz usunąć - z początku jego nazwy.
 
Krok 2: Dodawanie logiki
Teraz w pliku .sk musisz dodać logikę (kod) do Twojego nowego efektu/wyrażenia. Zakładając, że doszedłeś już tak daleko, zakładam, że rozumiesz, że będę tu tworzył implementację pliku exapmle.skq. Obowiązują tu zwykłe zasady Skript, niestandardowe elementy mogą być stosowane w tworzonej logice.

custom effect logic for "my custom effect":
    give 1 diamond to all players
    wait 10 seconds
    ban all players
custom expression logic for "answer to life":
    set expression value to 42
custom expression logic for "cool people":
    set expression value to "w00tmast3r", "MostFunGuy", "Nfell2009", "Njolbrim"
custom property logic for "%number% decrementation" of "number":
    set expression value to number origin expression - number expression 1
 

Podstawowe wyrażenia: lekka dokumentacja

# Dotyczy wszystkich przypadków gdy chcemy uzyskać wartość wyrażenia zdefiniowanego w składni tworząc logikę elementu
# Loopable (zapętlanie) dotyczy tylko wyrażeń, które zwracają wiele wartości (teksty, gracze, bloki, itp.)
# Type (typ) dotyczy typu, który oczekujesz, że zwróci wyrażenie (liczba, przedmiot, gracz, mob, itd.)
%type% [loopable] expression( |-)%number%
 
# Dotyczy tylko wyrażeń i własności (properties), określa to czym chcesz, żeby była wartość wyrażenia
[custom] expression ([return] value|output)
 
# Dotyczy tylko własnośći (properties), to samo co wyrażenie ale odnosi się do właściciela własności (np. player's sack, cheese of {_var})
%type% origin expression


Dokładniej opisująca i tłumacząca zagadnienie wersja poradnika:

Co chcemy zrobić?
Stworzyć własne efekty i wyrażenia dzięki nowej funkcji skQuery.
 
Zaczynamy
Tworzymy w folderze /scripts/ plik z rozszerzeniem .skq np "miniaddon.skq".
Jeśli nazwę pliku zaczniemy od myślnika "-" to plik nie zostanie wczytany (dokładnie tak jak wygląda to w przypadków zwykłych skryptów). 

W utworzonym pliku wpisujemy:
Jeśli chcemy utworzyć nowy efekt:
declare effect "<składnia Twojego efektu>"
-- np.:
declare effect "zabij adminow"
 
Jeśli chcemy utworzyć wyrażenie:
declare expression "<składnia Twojego wyrażenia>" as "<typ wartości, którą zwraca Twoje wyrażenie>"
-- np.:
declare expression "moje wyrazenie" as "boolean"
 
declare loopable expression "<sładnia>" as "<typ>"
-- to wyrażenie będzie zwracało kilka wartości i będzie je można zapętlać
-- np.:
declare loopable expression "pobliskie krowy" as "entity"

# w kodzie skryptu będzie można użyć pętli:
loop pobliskie krowy:
   ignite loop-entity
   kill loop-entity


declare property "<składnia>" as "<typ>" for "<typ obiektu, dla którego jest ta właściwość>"
-- to wyrażenie odwoływać będzie się do jakiegoś konkretnego typu
-- np.:
declare property "miejsce w rankingu" as "integer" for "player"

# w skryptach będziemy go używać w następujący sposób (np.):
send "miejsce w rankingu gracza %player-arg% to %miejsce w rankingu of player-arg%"


 
Parametry:
Podczas definiowania efektów i wyrażeń można użyć wyrażeń w samej składni, mianowicie np.:
declare effect "daj jablko dla %player%"
declare expression "%player% ma super zbroje" as "boolean"
i później w implementacji możemy pobrać wartość, która została wprowadzona w miejsce %player%.
Oczywiście zamiast player może być każdy inny typ (np. world, number, item, entity, itd.).
 
Komentarze:
Komentarze tworzymy zaczynając linię od dwóch myślników, np.:
-- to jest komentarz i ta linijka nie ma żadnego wpływu na działanie naszego mini-dodatku
 
Ważne:
Gdy uruchomimy serwer plik .skq zostanie "skomentowany" (na początku jego nazwy zostanie dodany myślnik) i w folderze /scripts/ zostanie automatycznie stworzony plik z rozszerzeniem .skqc.
Jeśli chcesz edytować plik .skq to musisz z jego nazwy usunąć myślnik, edytować plik i ponownie uruchomić serwer lub ewentualnie wykonać jego reload.
 
Implementacja stworzonych elementów
Żeby nasze efekty i wyrażenia coś robiły/zwracały musimy w zwykłym pliku .sk np. "miniaddon.sk" wpisać następujący kod:
 
W logice efektów i wyrażeń możemy używać następujących wyrażeń odwołujących się do zdefiniowanych parametrów:
# w efektach, wyrażeniach i własnościach (property)
# loopable tylko dla parametrów zwracających wiele wartości (teksty, gracze, itemy, liczby itp.)
# type to typ wyrażenia, do którego się odwołujesz (np. player, block, item, world itd.)
%type% [loopable] expression( |-)%number%
 
# tylko w wyrażeniach i własnościach (property)
# zapisujemy do tego wyrażenia to co ma zwracać nasze nowe wyrażenie/własność
[custom] expression ([return] value|output)
 
# tylko w własnościach (property)
# zwraca obiekt, do którego tworzymy naszą własność
# type to typ tego obiektu
%type% origin expression
 
Dla zdefiniowanych (w pliku .skq) efektów:
# efekt bez parametrów: 
custom effect logic for "zabij adminów":
    loop all players:
        loop-player is op
        kill loop-player
   broadcast "Wszyscy admini online zostali zabici."
 
# efekt z jednym parametrem:
custom effect logic for "daj jablko dla %player%":
    set {_p} to player expression 1
    if {_p} is op:
        give {_p} 5 gold apples
        send "dostales 5 zlotych jablek" to {_p}
    else:
        give {_p} 5 apples
        send "dostales 5 jablek" to {_p}
 
Dla zdefiniowanych wyrażeń:
custom expression logic for "moje wyrazenie":
    set expression value to true
 
# loopable expression:
custom expression logic for "pobliskie krowy":
    loop cows in radius 5 around player:
        add loop-cow to {_krowy:: *}
    set expression value to {_krowy:: *}
 
custom property logic for "miejsce w rankingu" of "player":
    set {_p} to player origin expression
    # kod na obliczanie miejsca w rankingu
    set expression value to {_miejsce}
 
custom expression logic for "%player% ma super zbroje":
    set {_p} to player expression 1
    set {_v} to 0
    if chestplate of {_p} is diamond chestplate named "super klata":
        add 1 to {_v}
    if boots of {_p} is diamond boots named "super kapcie":
        add 1 to {_v}
    if leggings of {_p} is diamond leggings named "super gatki":
        add 1 to {_v}
    if helmet of {_p} is diamond helmet named "super beret":
        add 1 to {_v}
    if {_v} is 4:
        set expression value to true
    else:
       set expression value to false


Powyższy poradnik opisuje funkcje dodane w najnowszej wersji dev skQuery, możliwej do pobrania z oficjalnej strony dodatku http://skquery.net.

 

Źródło: http://dev.bukkit.org/bukkit-plugins/skript/forum/tutorials/72019

 


Skript - sortowanie listy zmiennych - tworzymy top 5

Krótki poradnik jak posortować listę zmiennych od największej wartości do najmniejszej lub odwrotnie. :)

Skript - sortowanie listy zmiennych
Uczymy się sortować listę zmiennych, czyli tworzyć ranking.

I. O co chodzi?
O co w tym wszystkim chodzi? Co chcemy osiągnąć? Założenia.
W tym poradniku będziemy dążyć do stworzenia rankingu (dla przykładu: ilości wykopanego kamienia).
Poradnik ten jest adresowany do osób posiadających podstawową wiedzę o pisaniu skryptów dla pluginu Skript.

II. Tworzymy
... nasz ranking.
Na początek musimy stworzyć listę zmiennych przechowującą wartości liczbowe. W praktyce krok ten będzie polegał na przykład na stworzeniu skryptu zliczającego wykopany kamień.

on join:
	{stone::%player%} is not set:
		set {stone::%player%} to 0
	{nick::%player%} is not set:
		set {nick::%player%} to uncolored display name of player

on mine of stone:
	add 1 to {stone::%player%} 

Stworzyliśmy więc listę zmiennych w formacie {stone::nazwa_gracza} przechowującą wartość liczbową, w naszym przypadku ilość wykopanego przez gracza kamienia.
Dodatkowo stworzyliśmy zmienną przechowującą nick gracza z uwzględnieniem wielkości znaków.
Następnym krokiem będzie stworzenie komendy /top, która będzie wyświetlała 5 najlepszych kopaczy kamienia.

command /top [<integer=1>]:
	trigger:

		set {_strony} to rounded up (size of {stone::*} / 5)

		arg is between 1 and {_strony}:
			send "ranking kopaczy kamienia"

			loop {stone::*}:
				set {_lista::%loop-index%} to loop-value
			set {_num} to size of {_lista::*}

			set {_max} to arg * 5
			set {_min} to {_max} - 4

			loop {_max} times:
				loop {_lista::*}:
					{_wartosc.%loop-number%} is not set:
						set {_wartosc.%loop-number%} to loop-value
						set {_nazwa.%loop-number%} to loop-index
					loop-value is more than {_wartosc.%loop-number%}:
						set {_wartosc.%loop-number%} to loop-value
						set {_nazwa.%loop-number%} to loop-index
				remove {_wartosc.%loop-number%} from {_lista::*}
			loop {_max} times:
				loop-number is between {_min} and {_max}
				loop-number <= {_num}:
					send "%loop-number%. %{nick::%{_nazwa.%loop-number%}%}% (%{_wartosc.%loop-number%}%)"
			{_max} is more than {_num}:
				set {_r} to {_num}
				loop {_max} - {_num} times:
					add 1 to {_r}
					send "%{_r}%. brak"
			send "Strona: %arg% z %{_strony}%"
			stop

		{_strony} is 1:
			send "Wyniki mieszcza sie na 1 stronie."
			stop
		send "Wyniki mieszcza sie na %{_strony}% stronach."

Definiujemy komendę uwzględniając argument będący liczbą całkowitą wskazujący na stronę wyników którą chcemy zobaczyć.
Zapisujemy do zmiennej {_strony} ilość stron jaką zapełnią wyniki.
Sprawdzamy czy podana strona mieści się w przedziale od 1 do wcześniej zdefiniowanej zmiennej {_strony}.
Dla bezpieczeństwa kopiujemy naszą listę - tworzymy listę roboczą na której będziemy pracować.
Zapisujemy do zmiennej {_num} ilość wyników.
(w naszym przypadku kopaczy kamienia)
Zapisujemy do zmiennej {_max} nr ostatniego wyniku, który zmieści się na wybranej stronie.
(mnożymy stronę razy ilość wyników na stronie)
Do zmiennej {_min} zapisujemy nr pierwszego wyniku, który zmieści się na wybranej stronie.
(od zmiennej {_max} odejmujemy ilość wyników na stronie minus 1)
Sortujemy:
Zapętlamy {_max} ilość razy, czyli tyle do jakiego miejsca w rankingu potrzebujemy wyniki.
W każdym zapętleniu wykonujemy następujące czynności:
- zapętlamy listę
- zapisujemy wartość (do {_wartosc.%loop-number%}) i nazwę (do {_nazwa.%loop-number%}) pierwszej zmiennej. %loop-number% jest to numer zapętlenia, czyli pierwsze zapętlenie - 1, drugie - 2 itd...
- sprawdzamy wartość każdej zmiennej czy nie jest większa od tej zapisanej - jeśli jest nadpisujemy ją. w ten sposób po sprawdzeniu wartości wszystkich zmiennych w {_wartosc.%loop-number%} mamy zapisaną tą o najwyższej wartości
- usuwamy zapisaną zmienną z listy
i następne zapętlenie, czyli nasz kod się powtarza z tą różnicą, że zmienna o największej wartości jest już inna gdyż pierwszą usunęliśmy z listy.
Efektem naszej dotychczasowej pracy są pary zmiennych:
- {_wartosc.1}, {_nazwa.1} - przechowują zmienną o największej wartości
- {_wartosc.2}, {_nazwa.2} - przechowują zmienną o mniejszej wartości
- {_wartosc.3}, {_nazwa.3} - przechowują zmienną o mniejszej wartości
- itd...
Wyświetlamy:
Ponownie zapętlamy kod tyle razy, do którego miejsca w rankingu potrzebujemy wyniki.
W każdym zapętleniu wykonujemy następujące czynności:
- sprawdzamy czy numer zapętlenia mieści się w przedziale wyników, które chcemy zobaczyć na danej stronie
- sprawdzamy czy numer zapętlenia nie jest większy niż ilość wpisów z listy (w naszym przypadku kopaczy kamienia)
- jeśli powyższe warunki są spełniony wyświetlamy wiadomość "%loop-number%. %{nick::%{_nazwa.%loop-number%}%}% (%{_wartosc.%loop-number%}%)", która będzie miała postać np: "1. PiratJaskiniowy (99)"

Sortowanie wartości od najmniejszej do największej:
Co w przypadku gdy chcemy posortować listę w odwrotnym kierunku? Wystarczy w 12 linii zmienić "more" na "less". Otrzymamy wtedy wyniki w takiej formie jak wcześniej z tą różnicą, że zmienna {_wartosc.1} będzie przechowywać najmniejszą wartość.
 
Co się stanie gdy ostatnia strona nie zostanie zapełniona? - Będzie krótsza od reszty.
Możemy jednak temu zaradzić:
- Sprawdzamy czy taki stan ma miejsce. (czy maksymalna ilość wyników jest większa niż przechowywana w naszej liście)
- Zapisujemy ilość zmiennych w liście do {_r}.
- Zapętlamy kod /maksymalna ilość wyników minus liczba wpisów z naszej listy/ razy.
- Dodajemy 1 do {_r}.
- Wyświetlamy wiadomość "%{_r}%. brak", która będzie miała postać np: "33. brak".
 

autor: PiratJaskiniowy

 


Skript - pętle

Poradnik przedstawiający pętle w Skript. :)

Skript - pętle
Poznajemy pętle, ich rodzaje i przykładowe zastosowania.

I. Wstęp
Czym są pętle? Jak je dzielimy?
Pętle są wyrażeniami, dzięki którym możemy zapętlić w dany sposób/daną ilość razy jakiś kod.
Pętle dzielimy na dwie grupy:
- pętle skończone (wykonujące określoną ilość razy dany kod)
- pętle nieskończone (wykonujące dany kod przez cały czas działania skryptu)
wyjątkiem jest pętla while, która może być skończona lub nieskończona.

II. Pętle skończone
Czym się charakteryzują? Do czego można ich użyć?
Pętle skończone można podzielić na dwie grupy:
- pętle ze zdefiniowaną ilością zapętleń:

loop 13 times:
    # kod
loop {zmienna} times:
    # kod
loop 4*5+2^30 times
    # kod

W pętlach tych możemy się odwoływać do zmiennej loop-number, która przechowuje numer zapętlenia.
- pętle zapętlające daną grupę obiektów:

loop {lista::*}:
    # kod
loop all players:
    # kod
loop all sheeps in player's world:
    # kod
loop players in radius 4 of player:
    # kod
loop inventory of clicked block:
    # kod
loop inventory of arg:
    # kod
loop worlds:
    # kod
loop all dropped items:
    # kod

Każda z tych pętli może zawierać inne zmienne:
po zapętleniu listy zmiennych: loop-index - nazwa zmiennej, loop-value - wartość zmiennej
po zapętleniu graczy: loop-player - gracz
po zapętleniu owiec: loop-sheep (lub loop-entity) - owca
po zapętleniu ekwipunku: loop-item - przedmiot
po zapętleniu światów: loop-world - świat
Pętle te wykonają dany kod dla każdego obiektu z zapętlonej grupy.

Pętle w pętli
Jeśli tworzymy kilka pętli w sobie nawzajem i posiadają one zmienne o takich typach, aby się do nich odwołać musimy zdefiniować numer pętli w formacie: nazwa_zmiennej-numer_pętli np.: loop-number-2

loop 30 times:
    loop 4 times:
        loop-number-1 is 3:
            send "3"
        loop-number-2 is 4:
            loop-number-1 is 30
            send "ostatnie zapetlenie"

III. Pętle nieskończone
Czym się charakteryzują? Do czego można ich użyć?
Pętle nieskończone, jak sama nazwa wskazuje, wykonują dany kod nieograniczoną ilość razy.
Jako jedyne stanowią samodzielne jednostki(nie muszą być zawarte w komendach, zdarzeniach).

every <czas>:
    # kod
every 1 tick:
    # kod
every 5 hours:
    # kod

Dany kod będzie wykonywany w nieskończoność co zdefiniowany czas np. co 5 godzin.

IV. Pętla while
Czym się charakteryzuje? Do czego można jej użyć?
Ciekawą pętlą jest pętla while, gdyż może być zarówno skończona jaki i nieskończona.

while <warunek>:
    # kod

Słownie można opisać ją tak: Dopóki warunek jest spełniony wykonuje dany kod.

while 1 is 1:
    # kod

Powyższa pętla będzie wykonywała dany kod w nieskończoność. W praktyce jednak nie ma sensu tworzyć nieskończonej pętli while gdyż będzie ona działała tak samo jak pętle every. Jedyną różnicą jest ta, że jeśli kod w pętli nie będzie zawierał polecenia wait to nieskończona pętla while "zlaguje" serwer gdyż będzie on bez najmniejszej przerwy wykonywał kod w pętli "nie mając czasu" na żadne inne działanie.
Tak więc tworzenie nieskończonych pętli while - niewskazane!
Przy używaniu tej pętli warto zastosować zabezpieczenie przed nieskończonością, mianowicie:

set {_p} to 1
while <warunek>:
    # kod
    add 1 to {_p}
    {_p} is <limit powtorzen>:
        exit loop

V. Przykłady
Przykładowe zastosowania różnych pętli.
- Pętla every 5 seconds oraz zapętlenie wszystkich graczy na serwerze:

every 5 seconds:
    loop all players:
        {vampire.%loop-player%} is true
        sunlight level at the loop-player is greater than 10
        ignite the loop-player for 5 seconds

Działanie: jeśli zmienna {vampire.nazwa_gracza} ma wartość true i gracz przebywa w słońcu - będzie się palił.
- Zapętlenie wszystkich graczy:

command /ac [<text>]:
    trigger:
        loop all players:
            loop-player has permission "jestem.adminem":
                send arg to loop-player

Działanie: wysyła wiadomość do wszystkich graczy posiadających uprawnienie jestem.adminem.
- Pętla while:

on right click on sign:
    line 1 is "[sklep]"
    line 2 constains "S" and "K" and ":"
    set {_i} to 1
    while {_k} or {_s} is not set:
        line 2 of clicked block constains "S %{_i}%:":
            set {_s} to {_i}
        line 2 of clicked block constains ":%{_i}% K":
            set {_k} to {_i}
        add 1 to {_i}
        {_i} is 9999:
            exit loop
        send "Cena kupna: %{_k}%, Cena sprzedaży: %{_s}%"

Działanie: pętla while jest tu wykorzystana do pobrania kwoty kupna i sprzedaży z tabliczki o wzorze:
linia 1: [sklep]
linia 2: S <cena sprzedaży>:<cena kupna> K
Pętla będzie wykonywana tak długo, aż zmienne {_s} i {_k} będą zapisane lub gdy osiągnie 9999 powtórzeń.
 

autor: PiratJaskiniowy

 


Standard Skript Code Conventions r3

 

BZ8lAno.png

O co chodzi?
SSCC "Standard Skript Code Conventions" jest zestawem reguł pisania skryptów stworzonym przez destroyer'a4017.
Określa on styl kodowania, który zapewnia kompatybilność z innymi skryptami, łatwość utrzymania/modyfikowania kodu oraz sprawia, że skrypt jest prosty do odczytania.

Nazwy plików
Nazwy plików kończących się na ".sk" nie powinny zawierać następujących znaków:

  • #
  • `
  • $
  • %
  • {
  • }
  • (spacji)

Jeśli w nazwie chcesz zawrzeć wersję skryptu powinna ona znaleźć się na końcu, za nazwą skryptu: skrewards-v1.2.3.sk

Nazwy zmiennych
Poniższe zasady odnoszą się tylko do zmiennych globalnych, nie do lokalnych (zaczynających się od _).

Nazwy zmiennych powinny być zapisane według konwencji camelCase, gdzie nie występują spacje oraz pierwsza litera każdego słowa (wyłączając pierwsze) zaczyna się z wielkiej litery.

Zmienne tworzone przez skrypt powinny być definiowane w sposób {<nazwa skryptu>::<nazwa zmiennej>}, co ułatwia usuwanie danych danego skryptu albo aktualizowanie zmiennych z wcześniejszej wersji skryptu, na przykład:

# Zamiast takiej zmiennej
{current.reward}
# Użyj następującego wzoru
{skrewards::currentReward}

Zmienne dynamiczne oraz listy powinny być stopniowane, co jest bardziej obiektowym podejściem i umożliwia zapętlanie danych.

# Zamiast takich zmiennych
{reward.level.modifier.1}
{reward.level.modifier.2}
{reward.level.modifier.3}
{rewardstatus.%player%}
{info.%player%.mined.diamonds}
{info.%player%.mined.emeralds}
# Użyj następujących wzorów
{skrewards::rewardLevelModifier::1}
{skrewards::rewardLevelModifier::2}
{skrewards::rewardLevelModifier:: 3}
{skrewards::rewardStatus::%player%}

{skrewards::info::%player%::minedDiamonds}
{skrewards::info::%player%::minedEmeralds}
# Lub
{skrewards::info::%player%::mined::diamonds}
{skrewards::info::%player%::mined::emeralds}

Jeśli piszesz API,  powinieneś wpisać dane do zarezerwowanych nazw zmiennych {<nazwa skryptu>::api::<output ID>}. Jeśli używasz skQuery, możesz zapisywać dane do tych zmiennych gdy podprogram/funkcja jest wykonywany/a. W zwykłym Skript powinieneś zdeklarować komendy możliwe do użycia tylko z konsoli, które wpisują dane do tych zmiennych. Schemat ten pozwala twórcom skryptów tworząc własny skrypt pozyskiwać informacje z innych. Jeśli Twój skrypt jest BIBLIOTEKĄ, której jedynym celem jest udostępnienie funkcji, należy wtedy pominąć fragment ::api i używać {<nazwa skryptu>::<output ID>}. Zmienne API powinny być usunięte zawsze gdy serwer jest wyłączany.

Porządkowanie kodu
Stworzony kod musi być uporządkowany w określony sposób. Nie powinieneś wpisywać zdarzeń i komend w losowej kolejności; muszą być czytelnie oddzielone. Każdy z elementów może być pominięty, o ile są one w odpowiedniej kolejności.

  • script options (jeśli używasz skQuery)
  • aliasy   [aliases:]
  • zmienne  [variables:]
  • opcje  [options:]
  • podprogramy/funkcje (jeśli używasz skQuery)
  • nowe komendy  [command /komenda:]
  • on script load:
  • on script unload:
  • okresowe zdarzenia (np. every 10 seconds, at 10:00)
  • inne zdarzenia

Zdarzenia i Warunki
Zdarzenia zawsze powinny zaczynać się od słówka "on", mimo, że będą działać bez niego. Kiedy tylko to możliwe, powinieneś unikać używania selektorów w linii definiującej zdarzenie, np.:

on right click with porkchop:
on left click on tnt:
on damage of cow:

Należy uogólnić takie zdarzenia i skorzystać z warunków:

on right click:
    if tool of player is porkchop:
# dalszy kod
on left click:
    if clicked block is tnt:
# dalszy kod
on damage:
    if victim is a cow:
# dalszy kod

Stosując warunki, NIGDY nie powtórzysz tego samego zdarzenia kilka razy w jednym skrypcie.
 
Warunki powinny ZAWSZE zaczynać się od słówka "if" i kończyć dwukropkiem. NIGDY nie używaj warunków bez wprowadzenia dalszego kodu do ich wnętrza. To pozwoli twórcom skryptów w łatwy sposób dodać kod przed i po warunku albo dodać "else:".

# Zamiast
on damage:
    if victim is a player:
        {skrewards::info::%victim%::isInvincible} is true
        cancel event
        set {skrewards::info::%victim%::isInvincible} to false
# Użyj takich warunków
on damage:
    if victim is a player:
        if {skrewards::info::%victim%::isInvincible} is true:
            cancel event
            set {skrewards::info::%victim%::isInvincible} to false


Specyfikacja Lambdy
Lambdy są nową funkcją skQuery i mogą być używane we wszystkich wersjach powyżej 1.17.0. Pozwalają sporą ilość kodu skompresować do kilku linii. 
Lambdy, tak długo jak długo będą używane rozsądnie, będą spełniać wymagania SSCC. Lambdy mogą być brane pod uwagę jeśli:

  • Użyte są zamiast funkcji do wykonania POJEDYNCZEGO zadania
  • Użyte są do zaciemnienia kodu przez stworzenie bardzo skompresowanego kodu
  • Lepiej opisują ciąg zadań

- - -

Jeśli stosujesz się do tych zasad, umieść w publikacji swojego skryptu plakietkę: BZ8lAno.png
Kod z linkiem do oryginalnego tematu:

[url=http://dev.bukkit.org/bukkit-plugins/skript/forum/tutorials/69108/][img=http://i.imgur.com/BZ8lAno.png][/url] 

Kod z linkiem do tego tematu:

[url=http://skript.pl/index.php/topic/1877-][img=http://i.imgur.com/BZ8lAno.png][/url]

Źródło: http://dev.bukkit.org/bukkit-plugins/skript/forum/tutorials/69108

 


 
Zmiany:
(18.10.2013) Uzupełniłem rozdział nr 2.
(17.11.2014) Dodałem 5 poradników, które popełniłem w międzyczasie na innym forum.

Miecraft Maniak Pasjonat

Miecraft Maniak

Opublikowano
Pasjonat

Miecraft Maniak

Opublikowano

Pytanie: : jak zrobić aby to za każdą odp dostawało się 1 punkt który jest zapisywany do scorebar, i ostanie pytanie: jak zrobić aby gracz mógł napisać tyko 1 raz tą samą odp i po wpisaniu komendy /plugin stop można pisać do woli dobrą odp. ?

 

command /plugin [<text>]:
    trigger:
        set {slowo} to arg

on chat:
    message is {slowo}
    set message to "[Dobrze]"
    wait 1 tick
    send "Gratulacje odgadłeś pytanie."
PiratJaskiniowy Odkrywca

PiratJaskiniowy

Opublikowano
Odkrywca

PiratJaskiniowy

  • Autor
Opublikowano 
command /plugin [<text>]:
	trigger:
		arg is "stop":
			delete {gracze::*}
			delete {slowo}
			stop
		set {slowo} to arg

on chat:
	message is {slowo}
	loop {gracze::*}:
		loop-value is player:
			cancel event
			send "Juz odgadles to slowo."
			stop
	set message to "[Dobrze]"
	add "%player%" to {gracze::*}
	wait 1 tick
	send "Gratulacje odgadłeś pytanie."

Zrobiłem Ci wszystko prócz scoreboard bo z tego nigdy nie korzystałem więc niezbyt to ogarniam.

PiratJaskiniowy Odkrywca

PiratJaskiniowy

Opublikowano
Odkrywca

PiratJaskiniowy

  • Autor
Opublikowano

Dokończyłem rozdział drugi.

 

@Pytanie, jak zrobić w tym skrypcie co mi podałeś że po wpisaniu komendy /plugin Tekst do admina został wysłany tekst ?

command /plugin [<text>]:
	trigger:
		arg is "stop":
			delete {gracze::*}
			delete {slowo}
			send "[slowo] Wylaczyles gre."
			loop all players:
				loop-player has permission "jestem.adminem"
				send "[slowo] %player% wylaczyl gre." to loop-player
			stop
		set {slowo} to arg
		send "[slowo] Ustawiles slowo na: %arg%"
		loop all players:
			loop-player has permission "jestem.adminem"
			send "[slowo] %player% ustawil slowo na: %arg%" to loop-player

Wysyła wiadomość do gracza który użył komendy i do każdego z uprawnieniem jestem.adminem.

ElDorado123 Pasjonat

ElDorado123

Opublikowano
Pasjonat

ElDorado123

Opublikowano

zad 2:

 

command /pw [<player>] [<text>]:
    aliases: szept, msg, pm
    trigger:
        player has permission "wyslij.msg":
            arg 1 is set:
                arg 2 is set:
                    send "%player%: %arg 2%" to arg 1
                    stop
                send "Błąd w wysyłaniu wiadomości do %arg 1% (/pw %arg 1% <Tresc>)"
                stop
            send "Błąd (/pw <nick> <tresc>)"
            stop
        send "Nie możesz pisać prywatnych wiadomości. :("

Pisze pluginy na zamówienie ! Skype: elfusion200

adixadixb4 Pomocnik

adixadixb4

Opublikowano
Pomocnik

adixadixb4

Opublikowano

Chciałbym zastąpić podstawowa komendę Essentials, /msg na taką samą komendę ale z mojego skryptu. Jak to zrobić?

Jesli pomoglem daj Like.

Derout Pasjonat

Derout

Opublikowano
Pasjonat

Derout

Opublikowano

Czemu nie robią mi się te spacje? tzn klikam tab i tak jakby robi się jedna spacja i jak wcisnę enter to zaczyna od następnej linijki od początku i przez to skrypt nie dziala ;/

Gość

Gość

Opublikowano

Gość

Opublikowano

Dobrze napisane :) Jakbyś zrobił z kolorami i grafiką to było by czytelniej ;>

adixadixb4 Pomocnik

adixadixb4

Opublikowano
Pomocnik

adixadixb4

Opublikowano

Czemu nie robią mi się te spacje? tzn klikam tab i tak jakby robi się jedna spacja i jak wcisnę enter to zaczyna od następnej linijki od początku i przez to skrypt nie dziala ;/

Na jakim edytorze pracujesz?

Jesli pomoglem daj Like.

  • 1 miesiąc temu...
  • 9 miesięcy temu...
PiratJaskiniowy Odkrywca

PiratJaskiniowy

Opublikowano
Odkrywca

PiratJaskiniowy

  • Autor
Opublikowano

Z*******y turotail.

poradnik w miarę czytelny jednkaże dalej twierdze, że to nie moja bajka :)

Skoro nadal tu ktoś zagląda i pozytywnie odbiera treść tego poradnika to (jak znajdę chwilę wolnego czasu) go zaktualizuję (niektóre informacje są już nieaktualne), poprawię i możliwe, że dopiszę jakiś następny rozdział lub rozdziały.

Zarchiwizowany

Ten temat przebywa obecnie w archiwum. Dodawanie nowych odpowiedzi zostało zablokowane.

Tematy
×
×
  • Dodaj nową pozycję...