Dodawanie drzwi, bram i barierek

Drzwi, bramy oraz barierki są konfigurowane bezpośrednio w zasobie tW_gates.

Aby dodać nowe drzwi, bramy lub barierki, należy edytować plik:

Plik konfiguracyjny
tW_gates/s_gates.lua

Wszystkie wpisy znajdują się w tablicy cache.

Dokumentacja obejmuje dwa typy obiektów:

obiekty otwierane komendą,
obiekty otwierane przez detekcję gracza.

Źródłowy markdown opisywał oba warianty konfiguracji oraz pola takie jak modelId, position, rotation, argument, permissedTeams, colshapePosition, closeSide i moduloAnimate.

oaicite:0

Szybka instrukcja

Aby dodać drzwi, bramę lub barierkę:

Otwórz zasób tW_gates.
Przejdź do pliku s_gates.lua.
Znajdź tablicę cache.
Wybierz odpowiednią sekcję:
- commandGates — jeżeli obiekt ma być otwierany komendą,
- teamGates — jeżeli obiekt ma być otwierany przez detekcję gracza.
Wybierz typ obiektu:
- doors,
- gates,
- barriers.
Dodaj nowy wpis z pozycją, rotacją i pozostałymi wymaganymi danymi.
Zapisz plik.
Zrestartuj zasób tW_gates.

info

Konfiguracja drzwi, bram i barierek korzysta ze zwykłych tablic Lua.
Nie trzeba używać JSON-a ani narzędzia tableToJSON.

warning

Pamiętaj, aby każdy wpis w tablicy kończył się przecinkiem.
Brak przecinka może spowodować błąd w konfiguracji.

Rodzaje konfiguracji

W zasobie tW_gates dostępne są dwa główne sposoby działania obiektów.

Sekcja	Działanie
`commandGates`	Obiekty otwierane komendą
`teamGates`	Obiekty otwierane automatycznie przez detekcję gracza

Typy obiektów

W obu sekcjach można konfigurować kilka typów obiektów.

Typ	Opis
`doors`	Drzwi
`gates`	Bramy
`barriers`	Barierki / szlabany

Dodawanie obiektów na komendę

Obiekty otwierane komendą znajdują się w sekcji:

s_gates.lua
cache.commandGates

Tego typu drzwi, bramy lub barierki są otwierane po wpisaniu odpowiedniej komendy z argumentem.

Przykładowe komendy:

Przykładowe komendy
/drzwi arg1
/brama arg1
/szlaban arg1

Struktura konfiguracji na komendę

Przykładowa struktura dla drzwi, bram i barierek otwieranych komendą:

s_gates.lua
local cache = {
    commandGates = {
        doors = {
            { modelId = model, position = { x, y, z }, rotation = { rx, ry, rz }, interior = 0, dimension = 0, argument = 'arg1', permissedTeams = { 'police', 'medics' } },
            { modelId = model, position = { x, y, z }, rotation = { rx, ry, rz }, interior = 0, dimension = 0, argument = 'arg2', permissedTeams = { 'medics' } },
        },

        gates = {
            { modelId = model, position = { x, y, z }, rotation = { rx, ry, rz }, interior = 0, dimension = 0, argument = 'arg1' },
            { modelId = model, position = { x, y, z }, rotation = { rx, ry, rz }, interior = 0, dimension = 0, argument = 'arg2' },
        },

        barriers = {
            { position = { x, y, z }, rotation = { rx, ry, rz }, interior = 0, dimension = 0, argument = 'arg1' },
            { position = { x, y, z }, rotation = { rx, ry, rz }, interior = 0, dimension = 0, argument = 'arg2' },
        }
    },
}

Przykład dodania drzwi na komendę

s_gates.lua
local cache = {
    commandGates = {
        doors = {
            {
                modelId = 1495,
                position = { 1550.20, -1675.40, 16.20 },
                rotation = { 0, 0, 90 },
                interior = 0,
                dimension = 0,
                argument = 'komenda',
                permissedTeams = { 'police' },
            },
        },
    },
}

W tym przykładzie:

dodane zostaną drzwi o modelu 1495,
drzwi będą znajdować się na pozycji 1550.20, -1675.40, 16.20,
drzwi będą obrócone o 90 stopni na osi Z,
komenda będzie używać argumentu komenda,
dostęp do komendy będzie mieć tylko drużyna police.

Przykładowe użycie w grze:

Komenda
/drzwi komenda

Przykład dodania bramy na komendę

s_gates.lua
local cache = {
    commandGates = {
        gates = {
            {
                modelId = 980,
                position = { 1588.40, -1638.20, 14.80 },
                rotation = { 0, 0, 180 },
                interior = 0,
                dimension = 0,
                argument = 'parking',
            },
        },
    },
}

W tym przykładzie:

dodana zostanie brama o modelu 980,
brama będzie znajdować się na pozycji 1588.40, -1638.20, 14.80,
argument komendy to parking.

Przykładowe użycie w grze:

Komenda
/brama parking

Przykład dodania barierki na komendę

s_gates.lua
local cache = {
    commandGates = {
        barriers = {
            {
                position = { 1600.50, -1620.10, 13.50 },
                rotation = { 0, 0, 90 },
                interior = 0,
                dimension = 0,
                argument = 'wjazd',
            },
        },
    },
}

W tym przykładzie:

dodana zostanie barierka,
barierka będzie znajdować się na pozycji 1600.50, -1620.10, 13.50,
argument komendy to wjazd.

Przykładowe użycie w grze:

Komenda
/szlaban wjazd

Dodawanie obiektów na detekcję gracza

Obiekty otwierane przez detekcję gracza znajdują się w sekcji:

s_gates.lua
cache.teamGates

Tego typu drzwi, bramy lub barierki otwierają się automatycznie, gdy gracz z odpowiedniej drużyny znajdzie się w punkcie detekcji.

Punkt detekcji określa pole:

colshapePosition

Struktura konfiguracji na detekcję gracza

Przykładowa struktura dla drzwi, bram i barierek otwieranych przez detekcję gracza:

s_gates.lua
local cache = {
    teamGates = {
        doors = {
            ['police'] = {
                { modelId = model, position = { x, y, z }, rotation = { rx, ry, rz }, interior = 0, dimension = 0, colshapePosition = { x, y, z } },
                { modelId = model, position = { x, y, z }, rotation = { rx, ry, rz }, interior = 0, dimension = 0, colshapePosition = { x, y, z } },
            },

            ['medics'] = {
                { modelId = model, position = { x, y, z }, rotation = { rx, ry, rz }, interior = 0, dimension = 0, colshapePosition = { x, y, z } },
                { modelId = model, position = { x, y, z }, rotation = { rx, ry, rz }, interior = 0, dimension = 0, colshapePosition = { x, y, z } },
            },
        },

        gates = {
            ['police'] = {
                { modelId = model, position = { x, y, z }, rotation = { rx, ry, rz }, interior = 0, dimension = 0, colshapePosition = { x, y, z } },
                { modelId = model, position = { x, y, z }, rotation = { rx, ry, rz }, interior = 0, dimension = 0, colshapePosition = { x, y, z } },
            },

            ['medics'] = {
                { modelId = model, position = { x, y, z }, rotation = { rx, ry, rz }, interior = 0, dimension = 0, colshapePosition = { x, y, z } },
                { modelId = model, position = { x, y, z }, rotation = { rx, ry, rz }, interior = 0, dimension = 0, colshapePosition = { x, y, z } },
            },
        },

        barriers = {
            ['medics'] = {
                { position = { x, y, z }, rotation = { rx, ry, rz }, interior = 0, dimension = 0, colshapePosition = { x, y, z }, closeSide = 'left', moduloAnimate = true },
                { position = { x, y, z }, rotation = { rx, ry, rz }, interior = 0, dimension = 0, colshapePosition = { x, y, z }, closeSide = 'left' },
            },

            ['police'] = {
                { position = { x, y, z }, rotation = { rx, ry, rz }, interior = 0, dimension = 0, colshapePosition = { x, y, z }, closeSide = 'right' },
                { position = { x, y, z }, rotation = { rx, ry, rz }, interior = 0, dimension = 0, colshapePosition = { x, y, z }, closeSide = 'left' },
            },
        },
    },
}

Przykład dodania drzwi na detekcję gracza

s_gates.lua
local cache = {
    teamGates = {
        doors = {
            ['police'] = {
                {
                    modelId = 1495,
                    position = { 1550.20, -1675.40, 16.20 },
                    rotation = { 0, 0, 90 },
                    interior = 0,
                    dimension = 0,
                    colshapePosition = { 1550.20, -1675.40, 16.20 },
                },
            },
        },
    },
}

W tym przykładzie:

drzwi będą dostępne dla drużyny police,
drzwi będą znajdować się na pozycji 1550.20, -1675.40, 16.20,
punkt detekcji będzie ustawiony w tym samym miejscu co drzwi.

tip

colshapePosition najlepiej ustawić w miejscu, z którego gracz ma aktywować otwarcie obiektu.
Zazwyczaj jest to środek obiektu albo miejsce blisko wejścia.

Przykład dodania bramy na detekcję gracza

s_gates.lua
local cache = {
    teamGates = {
        gates = {
            ['police'] = {
                {
                    modelId = 980,
                    position = { 1588.40, -1638.20, 14.80 },
                    rotation = { 0, 0, 180 },
                    interior = 0,
                    dimension = 0,
                    colshapePosition = { 1588.40, -1638.20, 14.80 },
                },
            },
        },
    },
}

W tym przykładzie:

brama będzie dostępna dla drużyny police,
brama będzie otwierana automatycznie po wejściu w punkt detekcji,
punkt detekcji znajduje się na pozycji 1588.40, -1638.20, 14.80.

Przykład dodania barierki na detekcję gracza

s_gates.lua
local cache = {
    teamGates = {
        barriers = {
            ['police'] = {
                {
                    position = { 1600.50, -1620.10, 13.50 },
                    rotation = { 0, 0, 90 },
                    interior = 0,
                    dimension = 0,
                    colshapePosition = { 1600.50, -1620.10, 13.50 },
                    closeSide = 'right',
                },
            },
        },
    },
}

W tym przykładzie:

barierka będzie dostępna dla drużyny police,
barierka będzie znajdować się na pozycji 1600.50, -1620.10, 13.50,
barierka będzie zamykać się w stronę right.

Opis wymaganych pól

Poniżej znajduje się opis pól używanych przy dodawaniu drzwi, bram i barierek.

`modelId`

Pole modelId określa ID obiektu drzwi lub bramy.

Przykład:

ID modelu
modelId = 980

info

Pole modelId jest używane przy drzwiach i bramach.
Barierki mogą korzystać z domyślnego modelu ustawionego w skrypcie.

`position`

Pole position określa miejsce, w którym mają zostać ustawione drzwi, brama lub barierka.

Pozycja składa się z trzech wartości:

Wartość	Znaczenie
`x`	Pozycja na osi X
`y`	Pozycja na osi Y
`z`	Wysokość

Pozycję można pobrać w grze za pomocą komendy:

Komenda
gp

Przykład:

Pozycja obiektu
position = { 1550.20, -1675.40, 16.20 }

`rotation`

Pole rotation określa obrót drzwi, bramy lub barierki.

Rotacja składa się z trzech wartości:

Wartość	Znaczenie
`rx`	Obrót na osi X
`ry`	Obrót na osi Y
`rz`	Obrót na osi Z

Najczęściej do ustawienia kierunku obiektu wystarczy zmiana wartości rz.

Przykład:

Rotacja obiektu
rotation = { 0, 0, 90 }

tip

Wartość rz określa, w którą stronę będzie odwrócony obiekt.

`interior`

Pole interior określa ID interioru, w którym znajduje się obiekt.

Przykład:

Interior
interior = 0

Najczęściej, jeżeli obiekt znajduje się w zwykłym świecie gry, wartość powinna wynosić 0.

`dimension`

Pole dimension określa ID dimensionu, w którym znajduje się obiekt.

Przykład:

Dimension
dimension = 0

Najczęściej, jeżeli obiekt znajduje się w podstawowym świecie gry, wartość powinna wynosić 0.

`argument`

Pole argument określa drugą część komendy, którą należy wpisać, aby otworzyć dany obiekt.

Przykład:

Argument komendy
argument = 'parking'

Przykładowe użycie w grze:

Komenda
/brama parking

Dla różnych typów obiektów używane są różne komendy:

Typ obiektu	Komenda
Drzwi	`/drzwi <argument>`
Brama	`/brama <argument>`
Barierka	`/szlaban <argument>`

info

Pole argument jest używane przy obiektach otwieranych komendą, czyli w sekcji commandGates.

`permissedTeams`

Pole permissedTeams określa listę drużyn, które mają dostęp do danej komendy.

Przykład:

Dostępne drużyny
permissedTeams = { 'police', 'medics' }

Dostępne drużyny:

Klucz	Drużyna
`medics`	Medycy
`police`	Policja
`road_assistance`	Pomoc drogowa
`truckers`	Truckers
`petrol`	Petrol

tip

Jeżeli obiekt ma być dostępny dla kilku drużyn, wpisz je po przecinku w tablicy permissedTeams.

`colshapePosition`

Pole colshapePosition określa pozycję punktu detekcji.

Punkt detekcji to miejsce, w którym gracz musi się znaleźć, aby drzwi, brama lub barierka otworzyły się automatycznie.

Pozycja składa się z trzech wartości:

Wartość	Znaczenie
`x`	Pozycja na osi X
`y`	Pozycja na osi Y
`z`	Wysokość

Przykład:

Pozycja punktu detekcji
colshapePosition = { 1550.20, -1675.40, 16.20 }

tip

Aby zwizualizować punkt detekcji, wpisz w grze:

/devmode
/showcol

info

Pole colshapePosition jest używane przy obiektach otwieranych przez detekcję gracza, czyli w sekcji teamGates.

`closeSide`

Pole closeSide określa, w którą stronę ma zamykać się szlaban.

Dostępne wartości:

Wartość	Znaczenie
`right`	Szlaban zamyka się w prawą stronę
`left`	Szlaban zamyka się w lewą stronę

Przykład:

Strona zamykania szlabanu
closeSide = 'right'

info

Pole closeSide jest używane przy barierkach/szlabanach.

`moduloAnimate`

Pole moduloAnimate pozwala zmienić sposób animacji barierki.

Przykład:

Animacja barierki
moduloAnimate = true

Jeżeli barierka podczas zamykania obraca się dookoła w niepoprawny sposób, zmień wartość moduloAnimate.

Dostępne wartości:

Wartość	Znaczenie
`true`	Włącza alternatywny sposób animacji
`false`	Wyłącza alternatywny sposób animacji

tip

Jeżeli barierka zamyka się niepoprawnie, zmień moduloAnimate z true na false albo z false na true.

Podsumowanie

Aby dodać drzwi, bramę lub barierkę:

Edytuj plik tW_gates/s_gates.lua.
Wybierz sekcję commandGates albo teamGates.
Wybierz typ obiektu: doors, gates albo barriers.
Uzupełnij pozycję obiektu w position.
Uzupełnij obrót obiektu w rotation.
Ustaw interior oraz dimension.
Dla obiektów na komendę ustaw argument.
Dla obiektów na detekcję ustaw colshapePosition.
Pamiętaj o przecinku po każdym wpisie.
Zapisz plik i zrestartuj zasób tW_gates.

Najważniejsze pola:

Pole	Za co odpowiada
`modelId`	ID modelu drzwi lub bramy
`position`	Pozycja obiektu
`rotation`	Obrót obiektu
`interior`	Interior obiektu
`dimension`	Dimension obiektu
`argument`	Argument komendy
`permissedTeams`	Drużyny z dostępem do komendy
`colshapePosition`	Punkt detekcji gracza
`closeSide`	Strona zamykania szlabanu
`moduloAnimate`	Alternatywna animacja barierki

info

Konfiguracja drzwi, bram i barierek korzysta ze zwykłych tablic Lua.
Nie trzeba konwertować jej do JSON-a.

Szybka instrukcja​

Rodzaje konfiguracji​

Typy obiektów​

Dodawanie obiektów na komendę​

Struktura konfiguracji na komendę​

Przykład dodania drzwi na komendę​

Przykład dodania bramy na komendę​

Przykład dodania barierki na komendę​

Dodawanie obiektów na detekcję gracza​

Struktura konfiguracji na detekcję gracza​

Przykład dodania drzwi na detekcję gracza​

Przykład dodania bramy na detekcję gracza​

Przykład dodania barierki na detekcję gracza​

Opis wymaganych pól​

modelId​

position​

rotation​

interior​

dimension​

argument​

permissedTeams​

colshapePosition​

closeSide​

moduloAnimate​

Podsumowanie​

Szybka instrukcja

Rodzaje konfiguracji

Typy obiektów

Dodawanie obiektów na komendę

Struktura konfiguracji na komendę

Przykład dodania drzwi na komendę

Przykład dodania bramy na komendę

Przykład dodania barierki na komendę

Dodawanie obiektów na detekcję gracza

Struktura konfiguracji na detekcję gracza

Przykład dodania drzwi na detekcję gracza

Przykład dodania bramy na detekcję gracza

Przykład dodania barierki na detekcję gracza

Opis wymaganych pól

`modelId`

`position`

`rotation`

`interior`

`dimension`

`argument`

`permissedTeams`

`colshapePosition`

`closeSide`

`moduloAnimate`

Podsumowanie