Czasomierze i wydarzenia

Podczas rundy skrypty będą musiały śledzić czas i wysyłać sygnały między różnymi skryptami.Czas będzie zarządzany za pomocą skryptu czasowego, podczas gdy wydarzenia, koncepcja w kodowaniu Roblox, będą sygnalizować zmiany, takie jak koniec dopasowywać.

Wysyłaj sygnały za pomocą wydarzeń

Z graczami teraz na arenie wydarzenia mogą być używane do sygnalizowania rozpoczęcia meczu, a kod dla timera może rozpocząć się.Później wydarzenie może również zostać wykorzystane do sygnalizowania końca dopasowywaći że nadszedł czas, aby przenieść graczy z powrotem do lobby.

Te wydarzenia nie są wstępnie skonfigurowane, więc muszą zostać utworzone niestandardowe obiekty zdarzeń o nazwie wiązalne zdarzenia , które będą potrzebne.Wydarzenia wiązalne są często używane do działań uruchamianych przez gracza i są podobne do wydarzeń takich jak Touched lub Changed.

Wiele skryptów może słuchać tych samych zdarzeń przypisywalnych.To utrzymuje twój kod zorganizowany i ułatwia dodawanie dodatkowego kodu na początek lub koniec meczu później, jeśli jest to potrzebne.

Twórz wiązane wydarzenia

Zacznij od tworzenia wiązanych obiektów zdarzeń na początek i koniec dopasowywać.Ponieważ zdarzenia wiązalne nie interakują z klientem, mogą być przechowywane w przechowywaniu serwera.

W ServerStorage utwórz nową kategorię o nazwie Wydarzenia. W tej kategorii utwórz dwa Wiązalne wydarzenia o nazwie MatchStart i MatchEnd.

Użyj wydarzeń

W tej chwili, gdy gracze wchodzą na arenę, przerwa nadal się restartuje, zamiast rozpoczynać odliczanie czasu.Główny cykl gry musi być powiadomiony, aby się zatrzymać i poczekać, aż wydarzenie MatchEnd wystrzeli, zanim przejdzie do następnej części kodu.

Wydarzenia mają dwie wbudowane funkcje: Connect() i Wait().Zamiast używać Connect() tak jak wcześniej, wezwij Wait() na MatchEnd, aby wstrzymać skrypt menedżera gry, dopóki nie zostanie uruchomiony MatchEnd.W tym przypadku funkcja oczekiwania wstrzymuje kod, dopóki menadżer gry nie otrzyma sygnału, że mecz się zakończył.

W Menadżerze gry , utwórz zmienne dla katalogu Events i wydarzenia MatchEnd.


-- Skrypty modułowe
local moduleScripts = ServerStorage:WaitForChild("ModuleScripts")
local matchManager = require(moduleScripts:WaitForChild("MatchManager"))
local gameSettings = require(moduleScripts:WaitForChild("GameSettings"))

-- Wydarzenia
local events = ServerStorage:WaitForChild("Events")
local matchEnd = events:WaitForChild("MatchEnd")

Niech skrypt poczeka na wydarzenie końca meczu, aby wystrzelić przed kontynuacją. W pętli , na końcu , wpisywać:


while true do
	repeat
		task.wait(gameSettings.intermissionDuration)
		print("Restarting intermission")
	until #Players:GetPlayers() >= gameSettings.minimumPlayers

	print("Intermission over")
	task.wait(gameSettings.transitionTime)

	matchManager.prepareGame()
	-- Placeholder czeka na długość gra.
	matchEnd.Event:Wait()
end

Testuj grę.Potwierdź, że po wejściu graczy na arenę pętla przerwy nie kontynuuje się .Skrypt jest teraz w oczekiwaniu na sygnał matchEnd, aby wystrzelić.

Wskazówki dotyczące rozwiązywania problemów

W tym momencie kod nie działa tak, jak oczekiwano, spróbuj jednego z poniższych.

Podwójnie sprawdź użycie operatorów punktu lub przecinka w matchEnd.Event:Wait() .
Upewnij się, że MatchEnd jest BindableEventem, a nie innym wpisywać, takim jak RemoteEvent.

Użyj timera

Jednym z warunków, który spowoduje koniec meczu, jest wyczerpanie czasu, który zostanie obsłużony za pomocą skryptu.

Ustaw zegar

Aby dodać zegar do gra, użyj gotowego skryptu modułu w poniższych krokach.Zawiera funkcje do uruchomienia i zakończenia timera, a także zwrotu ilości czasu pozostałego.

W ServerStorage > ModuleScripts utwórz nowy skrypt modułu o nazwie Timer.

Zastąp kod kodem poniżej.


local Timer = {}
Timer.__index = Timer

function Timer.new()
	local self = setmetatable({}, Timer)

	self._finishedEvent = Instance.new("BindableEvent")
	self.finished = self._finishedEvent.Event

	self._running = false
	self._startTime = nil
	self._duration = nil

	return self
end

function Timer:start(duration)
	if not self._running then
		task.spawn(function()
			self._running = true
			self._duration = duration
			self._startTime = tick()
			while self._running and tick() - self._startTime < duration do
				task.wait()
			end
			local completed = self._running
			self._running = false
			self._startTime = nil
			self._duration = nil
			self._finishedEvent:Fire(completed)
		end)
	else
		warn("Warning: timer could not start again as it is already running.")
	end
end

function Timer:getTimeLeft()
	if self._running then
		local now = tick()
		local timeLeft = self._startTime + self._duration - now
		if timeLeft < 0 then
			timeLeft = 0
		end
		return timeLeft
	else
		warn("Warning: could not get remaining time, timer is not running.")
	end
end

function Timer:isRunning()
	return self._running
end

function Timer:stop()
	self._running = false
end

return Timer

W MatchManager wymagaj modułów GameSettings i Timer.


local MatchManager = {}

-- Usługi
local ServerStorage = game:GetService("ServerStorage")

-- Skrypty modułowe
local moduleScripts = ServerStorage:WaitForChild("ModuleScripts")
local playerManager = require(moduleScripts:WaitForChild("PlayerManager"))
local gameSettings = require(moduleScripts:WaitForChild("GameSettings"))
local timer = require(moduleScripts:WaitForChild("Timer"))

Poniżej zmiennych utwórz nowy obiekt czasomierza, ustawiając zmienną o nazwie myTimer równą timer.new().Ten obiekt zostanie wykorzystany do wezwania funkcji, które rozpoczynają i zatrzymują czasomierz.


local gameSettings = require(moduleScripts:WaitForChild("GameSettings"))
local timer = require(moduleScripts:WaitForChild("Timer"))

-- Tworzy nowy obiekt minutnika, który ma być używany do śledzenia czasu meczu.
local myTimer = timer.new()

Skrypt modułu czasomierza może być wywoływany przez inne skrypty, aby stworzyć więcej czasomierzy, jak potrzebujesz, na przykład jeśli chcesz, aby pułapki pojawiły się po określonym czasie.Aby używać timera w więcej niż jednej sytuacji, utwórz nowy obiekt Timer, tak jak myTrapTimer = timer.new().Obiekty czasomierza powinny być używane tylko do jednego celu, a nie ponownie używane.

Rozpocznij i zatrzymaj

Teraz, gdy utworzono czasomierz, użyj funkcji załączonych start() i stop() podczas dopasowywać.Poniżej jest opis każdej funkcji i parametru, który akceptuje.

start(time) - Rozpoczyna zegar, z czasem w sekundach jako parametrem.
finished:Connect(functionName) - Kiedy czasomierz się skończy, uruchamia funkcję przekazaną jako parametr.

W MatchManager , utwórz nową funkcję o nazwie timeUp(), która będzie uruchamiana za każdym razem, gdy skończy się czasomierz. Włącz oświadczenie o wydruku testowym.


local myTimer = timer.new()

-- Lokalne funkcje
local function timeUp()
	print("Time is up!")
end

-- Funkcje modułu
function MatchManager.prepareGame()
	playerManager.sendPlayersToMatch()
end

return MatchManager

Poniżej timeUp(), dodaj funkcję o nazwie startTimer() z oświadczeniem o drukowaniu. Wyświetlisz zegar w grze później.


-- Lokalne funkcje
local function timeUp()
	print("Time is up!")
end

local function startTimer()
	print("Timer started")
end

Aby uruchomić i zatrzymać zegar, w startTimer() :

Wezwij myTimer.start(). Przekaż gameSettings.matchDuration.
Wezwij myTimer.finished:Connect(). Przekaż timeUp().


-- Lokalne funkcje
local function startTimer()
	print("Timer started")
	myTimer:start(gameSettings.matchDuration)
	myTimer.finished:Connect(timeUp)
end

Uruchom czasomierz

Czasomierz może zostać uruchomiony na początku meczu za pomocą wydarzenia Rozpoczęcie meczu.

W MatchManager, pod zmiennymi modułu, utwórz zmienne, aby przechować katalog Wydarzeń, Początek meczu i Koniec meczu (które są używane w przyszłej lekcji).


-- Skrypty modułowe
local moduleScripts = ServerStorage:WaitForChild("ModuleScripts")
local playerManager = require(moduleScripts:WaitForChild("PlayerManager"))
local gameSettings = require(moduleScripts:WaitForChild("GameSettings"))
local timer = require(moduleScripts:WaitForChild("Timer"))

-- Wydarzenia
local events = ServerStorage:WaitForChild("Events")
local matchStart = events:WaitForChild("MatchStart")
local matchEnd = events:WaitForChild("MatchEnd")

--Tworzy zegar
local myTimer = timer.new()

Powyżej return MatchManager, połącz wydarzenie rozpoczęcia meczu z startTimer().


-- Funkcje modułu
function MatchManager.prepareGame()
	playerManager.sendPlayersToMatch()
end

matchStart.Event:Connect(startTimer)

return MatchManager

Aby uruchomić wydarzenie rozpoczęcia meczu, w prepareGame() , wpisz matchStart:Fire() .


-- Funkcje modułu
function MatchManager.prepareGame()
	playerManager.sendPlayersToMatch()
	matchStart:Fire()
end

Przetestuj gra. W oknie wyjściowym potwierdź, że możesz zobaczyć oświadczenia o drukowaniu dla funkcji startu i zatrzymywania czasomierza.

Zakończone skrypty

Poniżej są ukończone skrypty do sprawdzenia podwójnego swojej pracy.

Skrypt Menadżera meczów


local MatchManager = {}

-- Usługi
local ServerStorage = game:GetService("ServerStorage")

-- Skrypty modułowe
local moduleScripts = ServerStorage:WaitForChild("ModuleScripts")
local playerManager = require(moduleScripts:WaitForChild("PlayerManager"))
local gameSettings = require(moduleScripts:WaitForChild("GameSettings"))
local timer = require(moduleScripts:WaitForChild("Timer"))

-- Wydarzenia
local events = ServerStorage:WaitForChild("Events")
local matchStart = events:WaitForChild("MatchStart")
local matchEnd = events:WaitForChild("MatchEnd")

-- Tworzy nowy obiekt minutnika, który ma być używany do śledzenia czasu meczu.
local myTimer = timer.new()

-- Lokalne funkcje
local function timeUp()
	print("Time is up!")
end

local function startTimer()
	print("Timer started")
	myTimer:start(gameSettings.matchDuration)
	myTimer.finished:Connect(timeUp)
end

-- Funkcje modułu
function MatchManager.prepareGame()
	playerManager.sendPlayersToMatch()
	matchStart:Fire()
end

matchStart.Event:Connect(startTimer)

return MatchManager

Skrypt Menadżera gry


-- Usługi
local ServerStorage = game:GetService("ServerStorage")
local Players = game:GetService("Players")

-- Skrypty modułowe
local moduleScripts = ServerStorage:WaitForChild("ModuleScripts")
local matchManager = require(moduleScripts:WaitForChild("MatchManager"))
local gameSettings = require(moduleScripts:WaitForChild("GameSettings"))

-- Wydarzenia
local events = ServerStorage:WaitForChild("Events")
local matchEnd = events:WaitForChild("MatchEnd")

while true do
	repeat
		task.wait(gameSettings.intermissionDuration)
		print("Restarting intermission")
	until #Players:GetPlayers() >= gameSettings.minimumPlayers

	print("Intermission over")
	task.wait(gameSettings.transitionTime)

	matchManager.prepareGame()
	-- Placeholder czeka na długość gra.
	matchEnd.Event:Wait()
end

Na tej stronie