Problem wiedzowy na temat skryptów

3 minuty temu, Dawidek21 napisał:

Cześć, potrzebuje pomocy w temacie skryptu, (co logiczne patrząc po tym jakie to forum), jak napisać linijki w skrypcie żeby stawiając blok o danej nazwie co 10s dropiło na ten blok dany przedmiot w pętli tak długo jak gracz jest na chunku.

1. Jaki blok o jakiej nazwie?

2. Co dropiło?

3. Czy zamiast chunka może być po prostu 16 bloków od tego bloku?

1. Np Stawiając blok diamentu o nazwie Generator diamentów, żeby działalo a nie stawiając zwykły blok diamentowy.

2.Np. diament nad blok diamentu idąc tym przykładem.

3. Tak jak najbardziej.

14 minut temu, TeZetYT napisał:

1. Jaki blok o jakiej nazwie?

2. Co dropiło?

3. Czy zamiast chunka może być po prostu 16 bloków od tego bloku?

Aż tak precyzyjne informacje nie są potrzebne. Rozumiem, że autor wątku prosi o nakierowanie go na poprawną odpowiedź. Co do trzeciego pytania, 16 bloków od bloku to tworzenie regionu działania w kształcie koła o promieniu 16 bloków, co znacznie przekracza wymiary chunku (16x16).

23 minuty temu, Dawidek21 napisał:

Cześć, potrzebuje pomocy w temacie skryptu, (co logiczne patrząc po tym jakie to forum), jak napisać linijki w skrypcie żeby stawiając blok o danej nazwie co 10s dropiło na ten blok dany przedmiot w pętli tak długo jak gracz jest na chunku.

Po primo, aby sprawdzić nazwę stawianego bloku, należy sprawdzić nazwę bloku, który gracz trzyma w ręce. Jest to możliwe, ponieważ w momencie wywołania zdarzenia 'on place' blok jeszcze nie jest fizycznie postawiony. Tak więc, wyrażenie 'name of player's tool' okaże się tu przydatne.

Po secundo, tworzenie pętli jest silnie uzależnione od tego czy pętla ma się wykonywać do momentu wyjścia gracza z obszaru chunku, czy też zawsze będzie działać gdy będzie tylko w obszarze chunku.
Pierwszy scenariusz sugeruje użycie pętli 'while' sprawdzającej czy chunk w lokalizacji gracza ('chunk at player') jest taki sam jak w momencie rozpoczęcia pętli. Można go sobie zapisać przed rozpoczęciem pętli do zmiennej lokalnej i przyrównywać w każdej jej iteracji.
Drugi scenariusz natomiast skłania do użycia tzw. 'periodical', czyli fragmentu kodu wykonującego się okresowo (co określony czas).

Dopowiem, że jest drugi sposób na sprawdzanie czy gracz znajduje się w tym samym chunku - wystarczy sprawdzać współrzędne x i z chunku, które można obliczyć w prosty sposób (i jednocześnie najprostszy z punktu widzenia serwera):

set {_chunkX} to floor({_x} / 16)
set {_chunkZ} to floor({_z} / 16)

# Na przykład:
x = 28.339, y = 100.7, z = -11.21, wtedy: chunkX = floor(28.339 / 16) = 1, chunkZ = floor(-11.21 / 16) = -1

Rzecz jasna, współrzędna Y nie ma jakiegokolwiek wpływu na powyższe obliczenia.

Ostatnią sprawą wartą poruszenia jest to, że sprawdzanie co 10 sekund czy gracz jest w obrębie chunku będzie za sobą niosło konsekwencję możliwości wyjścia z obszaru chunku i powrotu do niego przed upłynięciem wspomnianych 10 sekund.

Na razie nie podaję żadnego kodu, ponieważ chcę sprawdzić czy moje wyjaśnienia i załączniki do dokumentacji przydały się jakkolwiek Panu.

Pozdrawiam.

Pomysł ze sprawdzaniem bloku w ręce gracza wydaje mi się tak szczerze całkiem przystępnym i przyjemnym pomysłem w realizacji. Patrząc po pomyśle na sprawdzenie lokalizacji chunka pomysł 2 scenariuszu wydaje się bardziej logiczny, oraz jestem w pełni świadom tej konsekwencji aczkolwiek jest ona porządana

@Dawidek21

Ponieważ napisał Pan do mnie wiadomość prywatną z prośbą o pokazanie trochę kodu, opisuję jak można podejść do tego problemu.

19 godzin temu, Dawidek21 napisał:

Pomysł ze sprawdzaniem bloku w ręce gracza wydaje mi się tak szczerze całkiem przystępnym i przyjemnym pomysłem w realizacji.

Cieszy mnie Pana entuzjazm, bo jest to jedyny możliwy sposób sprawdzenia nazwy xD. Blok po postawieniu traci (prawie) wszystkie informacje z okresu bycia przedmiotem w ekwipunku gracza i nazwa nie jest tutaj wyjątkiem.

19 godzin temu, Dawidek21 napisał:

Patrząc po pomyśle na sprawdzenie lokalizacji chunka pomysł 2 scenariuszu wydaje się bardziej logiczny

Oba sposoby są w pełni poprawne, ale moja intuicja podpowiada mi, że właśnie ten drugi sposób z obliczaniem koordynatów chunku jest bardziej solidny pod względem sposobu działania.

19 godzin temu, Dawidek21 napisał:

jestem w pełni świadom tej konsekwencji aczkolwiek jest ona porządana

W porządku.

Przejdźmy więc do pisania samego kodu. Zaznaczam, że nie podam na srebrnej tacy całego kodu. Warto, aby Pan również poznał podstawy Skripta. Myślę, że pokazanie wszystkiego na bazie pseudokodu i dalsze objaśnianie w razie potrzeby będzie najsensowniejsze. Podam również przydatne linki do nauki podstaw Skripta.

Kod z wykorzystaniem pętli while, która kończy się gdy gracz wyjdzie z obszaru chunku i nie wróci przed kolejną iteracją pętli:

przy postawieniu bloku:
	narzędzie gracza to ten konkretny blok diamentu:
		{pętlaDziała::%lokalizacja bloku%} == true:
			wyślij wiadomość "W tym miejscu działa wyrzucanie jeszcze poprzedniego bloku. Wykop go, odczekaj chwilę i spróbuj ponownie." do gracza
			stop
		{_blokChunkX} = floor(x bloku / 16)
		{_blokChunkZ} = floor(z bloku / 16)
		{pętlaDziała::%lokalizacja bloku%} = true
		tak długo jak {pętlaDziała::%lokalizacja bloku%} == true:
			{_graczChunkX} = floor(x gracza / 16)
			{_graczChunkZ} = floor(z gracza / 16)
			jeżeli {_graczChunkX} != {_blokChunkX} lub {_graczChunkZ} != {_blokChunkZ} lub {blokZniszczony::%lokalizacja bloku%} == true:
				wyjdź z pętli
			wyrzuć diament w miejscu bloku nad postawionym blokiem diamentu
			odczekaj 10 sekund
		wyczyść {pętlaDziała::%lokalizacja bloku%} i {blokZniszczony::%lokalizacja bloku%}
		
przy zniszczeniu bloku:
	zmienna globalna {pętlaDziała::%lokalizacja bloku%} jest ustawiona:
		{blokZniszczony::%lokalizacja bloku%} = true
		
przy wyładowaniu skryptu:
	wyczyść listy {pętlaDziała::*} i {blokZniszczony::*}

Zaleta powyższego rozwiązania: łatwiej jest pobrać gracza, który postawił blok.
Wada powyższego rozwiązania: zarządzanie pętlą jest trudniejsze ze względu na konieczność zapobieżenia tworzeniu wielu pętl while (co jest obciążające dla serwera).

Kod z wykorzystaniem periodicala (kodu wykonującego się okresowo) tak długo jak gracz jest w obszarze chunku:

przy postawieniu bloku:
	narzędzie gracza to ten konkretny blok diamentu:
		dodaj lokalizację bloku do listy {generatory::*}
		{graczStawiającyBlok::%lokalizacja bloku%} = gracz

przy zniszczeniu bloku:
	# opcjonalnie w tym miejscu: czy blok to blok diamentu
	lista {generatory::*} zawiera lokalizację bloku:
		usuń lokalizację bloku z listy {generatory::*}
		wyczyść {graczStawiającyBlok::%lokalizacja bloku%}
		
co 10 sekund:
	zapętl listę {generatory::*}:
		{_gracz} = {graczStawiającyBlok::%loop-value%}
		jeżeli {_gracz} jest offline:
			pomiń tę iterację (continue)
		{_blokChunkX} = floor(x loop-value / 16)
		{_blokChunkZ} = floor(z loop-value / 16)
		{_graczChunkX} = floor(x {_gracz} / 16)
		{_graczChunkZ} = floor(z {_gracz} / 16)
		jeżeli {_graczChunkX} != {_blokChunkX} lub {_graczChunkZ} != {_blokChunkZ}:
			pomiń tę iterację (continue)
		{_lokalizacjaNad} = loop-value
		dodaj 1 do y {_lokalizacjaNad}
		wyrzuć diament w miejscu {_lokalizacjaNad}

Zaleta powyższego rozwiązania: łatwiej zarządza się pętlą, nie musimy się martwić tworzeniem wielu pętl działających jednocześnie.
Wada powyższego rozwiązania: trzeba przechowywać informację o graczu, który postawił blok.

Powyższe kody można zmodyfikować tak, aby działały na dowolnych graczy. W istocie, jest to niewielkie rozwinięcie obu kodów.

Przydatne linki do nauki Skripta:

• dokumentacja Skript,
• wiki Skripta prowadzone przez te forum,
• całe forum skript.pl, szczególnie sekcje z poradnikami i promowanymi skryptami.

Pozdrawiam.

Dziękuję pięknie za pomoc, pozdrawiam.

Problem został rozwiązany.