➤ Tutorial: guía intermedia para la creación de scripts 🕹

Página de tutoriales Este artículo es un tutorial intermedio.Todos los tutoriales · Tutoriales de secuencias de comandos

¡Bienvenido a las secuencias de comandos intermedias! Si aún no lo ha hecho, consulte la guía para principiantes de secuencias de comandos. Este tutorial de secuencias de comandos le enseñará cómo escribir secuencias de comandos en un nivel intermedio, en primer lugar, como por supuesto hay con todos los otros tutoriales de secuencias de comandos, hay -bueno- más de unos pocos conceptos que debe haber aprendido primero: eventos, métodos, tablas, bucles, declaraciones "if", declaraciones "else" y declaraciones "elseif".

Contenido

1 Solo una reseña rápida
2 Si declaraciones
- 2.1 Operadores relacionales
- 2.2 Operadores aritméticos
- 2.3 Operadores lógicos
- 2.4 Valores de verdad / falsedad
3 Declaraciones Else, Elseif y Nesting If
Servicio 4
5 Parámetros
- 5.1 Tuplas
6 Regreso
7 Eventos
8 Instancia
9 funciones integradas
- 9.1 Destruir ()
- 9.2 Clonar ()
- 9.3 ClearAllChildren ()
- 9.4 FindFirstChild ()
- 9.5 WaitForChild ()
- 9.6 Espere ()
10 mesas
11 bucles
- 11.1 Bucles while
- 11.2 Para bucles
- 11.3 Bucles en pares
12 ¿Qué significa "local"?
13 Secuencias de comandos intermedias: ejemplos
- 13.1 Ladrillo para matar / curar de usos múltiples (dificultad: media-difícil)
  - 13.1.1 Extensión: efecto curativo extendido
  - 13.1.2 Extensión: efecto de desaparición
  - 13.1.3 Grabación del jugador
- 13.2 La puerta VIP (dificultad: media)

Solo una reseña rápida

Aquí hay algunos conceptos que debe conocer de antemano:

Variables: marcadores de posición para datos
Booleanos: declaraciones verdaderas / falsas
Valores de cadena: valores de texto
Propiedades: atributos de un objeto
Funciones: marcadores de posición para el código
Padre: el objeto directamente encima de otro objeto en la ventana del Explorador
Niño: el objeto directamente debajo de otro objeto en la ventana del Explorador

Debe tener Roblox Studio abierto para esto, y también debe tener un script abierto, así como su Explorador, Propiedades y Salida abiertos.

Si declaraciones

An si la declaración ejecutaría un fragmento de código if se cumple una condición. Por ejemplo:

1 local Var = 1 2 si Var == 1 luego 3 print ("condición cumplida") 4 end

Puede ver que estoy declarando una variable. Luego, el script se encontrará con la declaración if. La secuencia de comandos encuentra que Var es 1, por lo que la condición se cumple, por lo tanto, imprimirá "condición cumplida". ¡No olvide las etiquetas finales! Tenga en cuenta que en una instrucción if se debe usar ==. == es para comparar valores y = es para declarar variables.

Operadores relacionales

Si aún no está familiarizado con los operadores relacionales, un operador relacional es un operador que compara dos números. Como tal, solo se pueden usar en valores flotantes e int. Aquí están:

== (igual a)
~ = (No es igual a)
<(Menor que)
> (Mayor que)
<= (Menor o igual a)
> = (Mayor o igual que)

Entonces, por ejemplo, algunas declaraciones serían:

Tutorial: guía intermedia para la creación de scripts

Como referencia, si está confundiendo los símbolos mayor que (>) y menor que (<), me gusta pensar en estos símbolos como una boca de cocodrilo que "come" el número mayor.

Operadores aritméticos

Si tiene algún conocimiento de matemáticas, debe saber que los números se pueden cambiar con operadores. Estos son:

+ (Agregar)
- (restar)
* (Multiplicar)
/ (Dividir)
% (Módulo)
^ (Exponentes)

Asi que...

Tutorial: guía intermedia para la creación de scripts

Si no tiene claro los dos últimos operadores, módulo devuelve el recordatorio cuando se dividen los dos números. Así por ejemplo,

Tutorial: guía intermedia para la creación de scripts

Como 7 no es perfectamente divisible entre 2, deja un resto de 1. Por lo tanto, 7 mod 2 es 1.

Los exponentes son solo multiplicaciones repetidas.

Tutorial: guía intermedia para la creación de scripts

Entonces, 5 ^ 5 es solo 5 multiplicado por sí mismo 3 veces.

Para realizar una operación sobre un valor, debe realizar una operación aritmética con el valor, como muestra este ejemplo:

1 valor = valor + 1: agrega 1 al valor. 2 valor = valor - 1 - Resta 1 del valor. 3 valor = valor / 2 --Divide el valor entre 2. 4 valor = valor * 3 --Multiplica el valor por 3. 5 valor = valor% 3 --Divide el valor por 3, luego devuelve el resto. 6 valor = valor ^ 5: multiplica el valor por sí mismo 5 veces.

Para mayor simplicidad, estas operaciones se pueden acortar, como muestra este ejemplo:

1 valor + = 1 - suma 1 al valor 2 valor - = 1 - (quita 1 del valor) 3 valor * = 2 - (multiplica el valor por 2)

Aquí hay un ejemplo de un operador aritmético que prueba si el jugador tiene suficiente dinero o no:

1 si plr.Money.Value> = 120 entonces 2 plr.Money.Value - = 120 3 fin

Aquí, verifica si el jugador posee $ 120 o más. Si es así, lo restaría.

Operadores logicos

Un operador lógico combina dos operadores juntos en uno. Estos son:

y (comprueba si AMBAS condiciones son verdaderas)
or (comprueba si CUALQUIER condición es verdadera)
no (comprueba si el estado actual es OPUESTO a la condición)

1 si valor <30 y valor> 15 entonces 2 --Código 3 final 4 5 si valor == "queso" o valor == "pastel" entonces 6 - Código 7 final 8 9 si no es valor == 12 entonces 10 - -Código 11 final

La primera instrucción if verifica si el valor es menor que 30, pero mayor que 15. En otras palabras, verifica si el valor está entre 15 y 30. La segunda instrucción if verifica si el valor es "queso" o "pastel", y el tercero comprueba si el valor es no 12.

Valores de verdad / falsedad

Pero ¿qué significa esto?

1 si valor entonces 2 imprimir ("Oof") 3 fin

Si hay no operadores, la sentencia if comprueba si el valor es veraz or falsedad.

Para ser claro, un falsedad valor (también conocido como Falsey value), es un valor que es false or cero.

Todos los demás valores se consideran veraz valores.

La mayoría de las veces, esto se usa para encontrar si un ejemplo existe. Entonces, si tuviera que hacer esto,

1 local Head = script.Parent: FindFirstChild ("Head") 2 3 si Head, luego 4 print ("Mi padre tiene una cabeza") 5 end

Te explicare mas adelante que FindFirstChild () lo hace más tarde, pero básicamente, encuentra la parte denominada Head.

Este script comprobará si su padre tiene un hijo llamado "Head". Si lo hace, imprime.

Declaraciones Else, Elseif y Nesting If

También puede poner una instrucción if dentro de otra. Se llama anidación una declaración if.

1 local Var1 = 1 2 local Var2 = falso 3 si Var1 == 1 luego 4 si Var2 == falso 5 imprimir ("Oof") 6 final 7 final

El script verá que se cumplen ambas condiciones, por lo que imprime. Recuerde, cada declaración if necesita su propia etiqueta final.

Colocación más en la instrucción if hará que el script ejecute un código alternativo si no se cumple la primera condición.

1 local Var1 = 1 2 si Var1 == 2 entonces 3 print ("condición cumplida") 4 else 5 print ("condición no cumplida") 6 fin

An de lo contrario es básicamente combinar "else" con una instrucción if. Si no se cumple la primera condición, comprobará si se cumple una segunda condición.

1 local Var1 = 1 2 local Var2 = falso 3 si Var1 == 2 luego 4 print ("condición 1 cumplida") 5 elseif Var2 == falso luego 6 print ("condición 2 cumplida") 7 end

Entonces, el sistema define ambas variables, luego tiene que decidir si Var1 es igual a 2. No lo es, por lo que verifica la otra condición. Se cumple, por lo que imprime "Condición 2 cumplida". Puede hacer declaraciones if tan locas como desee, con tantos elseifs y declaraciones if anidadas como desee.

Servicios

Un servicio es cualquier cosa del nivel jerárquico más alto en la ventana del Explorador. Aquí están:

Espacio de trabajo: un servicio que contiene todas las partes y objetos físicos del juego.
Jugadores: servicio que gestiona a todos los jugadores que entran al juego.
Iluminación: gestiona los efectos de iluminación, la hora del día y el sol, la luna y el cielo.
ReplicatedStorage: servicio que contiene objetos replicados a todos los clientes
ServerScriptService: Servicio que contiene secuencias de comandos del servidor; scripts que se utilizarán para todo el juego, es decir, para las tablas de clasificación.
ServerStorage: Almacenamiento para objetos que se utilizarán más tarde.
StarterGui: Servicio que contiene ScreenGuis
StarterPack: servicio que contiene herramientas
SoundService: almacenamiento para audio
Chat: administra el chat
LocalizationService: gestiona la traducción automática

Hay mucho que desempacar, así que concéntrate en Espacio de trabajo, ya que es el servicio más utilizado y el único que se utiliza en este tutorial. En el tutorial avanzado, comenzaremos a usar StarterGui.

También hay dos servicios que puede agregar manualmente a la ventana del Explorador: ReplicatedScriptService y Equipos. Para agregarlos, abra el Ver ficha > Barra de comando. Luego, ingrese lo siguiente:

1 juego: GetService ("ReplicatedScriptService") 2 juego: GetService ("Equipos")

Estos servicios aparecerán en su Explorer.

Por supuesto, hay muchos otros servicios ocultos en la ventana del Explorador. Para acceder a ellos dentro de una secuencia de comandos, debe utilizar el GetService () función para obtener el servicio. Por ejemplo:

1 UserInputService local = juego: GetService ("UserInputService")

Ahora, dentro del guión, el servicio UserInputService estará contenido dentro de la variable "UserInputService".

parámetros

En el tutorial para principiantes, expliqué qué era una función: un marcador de posición para el código. También podemos permitir que una función tenga un argumentoy parámetro (un valor que debe ingresarse), por ejemplo:

1 función escribir (cosas) 2 imprimir (cosas) 3 finalizar 4 5 escribir ("¡Hola mundo!")

Al declarar una función, al poner un parámetro entre corchetes, la función espera un valor. Luego, cuando llame a la función, deberá poner un valor entre corchetes. En este caso, la función espera un valor para "cosas". Cuando llama a la función, poniendo "¡Hola mundo!" entre paréntesis, está definiendo "cosas" como la cadena "¡Hola mundo!" A partir de ahí, puede usar "cosas" como una variable dentro de la función.

Tuples

También podemos hacer esto:

1 función escribir (cosas, más cosas) 2 imprimir (cosas) 3 imprimir (más cosas) 4 finalizar 5 6 escribir ("¡Hola", "mundo!")

El script anterior espera dos parámetros: cosas y mas cosas. Al llamar a la función, definimos cosas as Hola y mas cosas as ¡mundo!.

Puede tener tantos parámetros como desee siempre que los separe con comas. Cuando usamos más de un argumento, lo llamamos un tupla.

Volviendo

Devolver un valor es una forma en que una función genera un valor. Un ejemplo real de esto es que Google devuelve resultados para su búsqueda.

Digamos que quería hacer un convertidor que duplicara el número de entrada. Simplemente haz esto:

1 función local DoubleNumber (InputNumber) 2 local OutputNumber = InputNumber * 2 3 return OutputNumber 4 end 5 local Multiply = DoubleNumber (10) 6 print (Multiplicar)

Aquí, la cuarta línea le dice que active la función DoubleNumber. La función duplica 10 para hacer 20 y devuelve 20. Este número está contenido en la variable "Multiplicar". Esta variable se puede utilizar para la declaración de impresión en la línea 6.

Eventos

Los eventos son básicamente situaciones especiales que pueden programarse para provocar una reacción. El más común es Touched, que se puede aplicar a Piezas y Uniones. Siempre que algo toca una parte, hace que se llame a una función.

1 función onTouch () 2 print ("me tocaron D =") 3 final 4 5 script.Parent.Touched: connect (onTouch)

Analicemos esto.

"script.Parent"Obviamente se refiere a la parte que se tocó. Conéctate(), como sugiere el nombre, conecta el evento a la función. En otras palabras, siempre que ocurre el evento (cuando la parte es tocada por una parte o un jugador), la función se activa.

Los eventos también tienen parámetros incorporados. En el evento Tocado, su parámetro es la persona o cosa que lo tocó.

1 función onTouch (con toque) 2 con toque: Destroy () 3 final 4 5 script.Parent.Touched: conectar (onTouch)

En este caso, se llama a la cosa que tocó el objeto "que tocó". Entonces, cuando desencadena el evento, dispara la función y la función destruye lo que desencadenó el evento.

Hay una gran cantidad de otros eventos, pero para los scripters intermedios, Touched será el más importante.

Otra forma de disparar un evento es hacer esto:

1 script.Parent.Touched: Connect (función (whoTouched) 2 whoTouched: Destroy () 3 end)

Esta es una forma de utilizar menos líneas.

Ejemplo

Una instancia es cualquier objeto o propiedad del juego. ¿Qué sucede si desea crear un script que cree una pieza? PODRÍAS hacer esto.

1 bloque local = Instance.new ("Part", game.Workspace)

Aquí, estoy creando una nueva instancia. El primer parámetro, "Part" es el nombre de clase de la instancia, o qué tipo de objeto es. Entonces, estoy creando una parte. También tiene un segundo parámetro, para su padre.

Sin embargo, esta es una mala práctica común. Nunca es una buena idea utilizar el parámetro Parent. Esto solo hace que la función sea más lenta.

En su lugar, defina el padre en la siguiente línea.

1 ladrillo local = Instance.new ("Part") 2 Brick.Parent = juego.Workspace

¿Y si queremos establecer propiedades? Sencillo. Después del código anterior, escriba esto:

1 Brick.Transparency = 1 2 Brick.Name = "Bloque"

El sistema ya sabe lo que Ladrillo medio. Simplemente configure las propiedades.

Funciones integradas

Estas son las funciones que se establecen en el juego, y no se puede declarar ninguna función personalizada con el nombre.

Destruir()

Esta función establece efectivamente el padre del objeto en cero, eliminándolo del juego. Por ejemplo:

1 script Padre: Destruir ()

Clon()

Hace un duplicado de la pieza, con todas las mismas propiedades, excepto el con el futuro bebé. Aún necesita definirlo en la siguiente línea.

1 local Clon = script.Parent: Clone () 2 Clone.Parent = juego.Workspace

ClearAllChildren ()

Destruye a todos los hijos del objeto. Como ejemplo, si usara esto en el espacio de trabajo, eliminaría todo en el espacio de trabajo.

1 script Padre: ClearAllChildren ()

FindFirstChild ()

Si no está seguro de si existe o no una variable o Instancia, FindFirstChild () accederá al objeto si existe; de lo contrario, el script seguirá ejecutándose, mientras que si simplemente intenta acceder a un valor nulo, el script se romperá.

Para ejecutar código solo si existe algo, use una instrucción if para ejecutar solo el código si el objeto en FindFirstChild no es igual a nil.

1 script Padre: FindFirstChild ("Fuego")

WaitForChild ()

Similar a FindFirstChild, pero en lugar de devolver un valor nulo si el objeto no existe, lo haría rendimientoy esperar.

1 juego. Espacio de trabajo: WaitForChild ("Part") 2 print (1)

Aquí, el guión esperar para una instancia denominada "Parte", y nunca continuará HASTA que exista.

Esperar()

Retrasa un código un número determinado de segundos. Establezca el tiempo en segundos como parámetro. Si no hay ningún parámetro, por defecto esperará 1 segundo. Esto también espera si no hay ningún número entre paréntesis, aunque durante un período de tiempo extremadamente corto.

1 espera (0.5) - Demora medio segundo. 2 wait (): demora 1 segundo. 3 espera (2): demora 2 segundos.

Mesas

Las tablas, también conocidas como matrices, son un tipo de variable en Lua que se puede usar para almacenar múltiples datos en la misma variable, por ejemplo:

1 a = {a, b, c}

Ahora necesita saber que hay dos valores principales de una tabla: i y v. I, o Posición del índice, es la posición del valor en la tabla. En la tabla anterior, debido a que "a" es el primer número, su valor i es 1. "b" es el segundo valor, por lo que su valor i es 2 y el valor i de c es 2. v, o Ahorro, es la pieza de datos en sí misma.

Entonces, si desea encontrar el valor de v dado el valor de i, tendrá que hacer esto.

1 a [2]

Lo que esto básicamente hace es decirle a nuestro script que acceda al segundo valor en la tabla a. Ahora, digamos que queríamos imprimir los 2 últimos valores de la siguiente tabla:

1 a = {"tres mil", "novecientos", "y uno"}

Lo que haríamos es esto:

1 impresión (a [2]) 2 impresión (a [3])

También podemos asignar valores a espacios individuales dentro de una tabla:

1 a [2] = "lol" 2 imprimir (a [2])

Esto imprimiría el texto lol en nuestra salida, porque el valor del segundo espacio en la tabla "a" se cambió a "lol".

bucles

A loops es básicamente un fragmento de código que se ejecuta repetidamente. Tenga en cuenta que independientemente del tipo de bucle que utilice, DEBE utilizar una función de espera (retardo). Esto se debe a que el sistema ejecutará el código tan infinitamente rápido que, sin demora, el servidor se bloqueará y dejará de responder.

Mientras bucles

El ciclo más simple es un ciclo "while", que básicamente actúa así:

1 a = verdadero 2 mientras a == verdadero hacer 3 esperar (0.1) 4 imprimir ("Puedo blandir mi espada") 5 fin

Básicamente, lo que hace es que el script comprueba continuamente si a sigue siendo verdadero cada 1 segundos, y si a sigue siendo cierto, el código dentro del bucle se ejecutará de nuevo.

Si quisiera un bucle while para seguir ejecutando código incondicionalmente, haría esto:

1 mientras es verdadero hacer 2 - Código 3 final

Para bucles

Un segundo ciclo más complicado es el ciclo "for", que puede repetirse un número determinado de veces, por ejemplo:

1 para i = 1,6 do 2 espera (0.1) 3 print ("¡Hola mamá!") 4 end

Básicamente, lo que hace es que el script cuente de 1 a 6, ejecutando el código cada vez. Entonces, "¡Hola mamá!" se imprimiría 6 veces.

Si quieres ponerte elegante ...

Agregar la tercera parte hace que nuestro bucle for cuente en 2, lo que significa que nuestro script contará de 2 a 6 en 2, y se ejecutará cada vez que pueda agregar 2 a 2 antes de que se convierta en 6.

1 para i = 2,6,2 do 2 espera (0.1) 3 print ("¡Hola papá!") 4 end

También podemos imprimir i:

1 para i = 1,6 hacer 2 esperar (0.1) 3 imprimir (i) 4 finalizar

Lo que esto básicamente hace que nuestro script haga es contar de 1 a 6 y cada vez que cuenta 1, imprime el valor que tenga.

En pares de bucles

Este ciclo requerirá una comprensión de las tablas, que debería haber aprendido anteriormente.

Un ciclo en pares es un ciclo que involucra los valores en una tabla.

1 local Parts = game.Workspace.Folder: GetChildren () 2 para índice, Parte en pares (Partes) hacer 3 imprimir (índice) 4 Parte: Destruir () 5 esperar (0.5) 6 finalizar

Lo que hace GetChildren () es que devuelve una matriz que contiene todos los valores de instancia dentro de cada carpeta. Luego, cambié el nombre de i a index yv a Part. Luego, le dije al guión qué tabla quería usar después de "en parejas". Luego, entre intervalos de medio segundo, el script contaba el número de partes a medida que destruye cada parte una por una.

¿Qué significa "local"?

En el Tutorial para principiantes, mencioné que las variables deben tener 'local' delante. Ahora que ha aprendido algunas habilidades importantes, puedo explicar lo que significa.

Tutorial: guía intermedia para la creación de scripts

Para comprender esto, debe comprender los bloques. Notarás que te pedí que aplicaras sangría al código en declaraciones if, funciones y bucles. El código completo es un bloque de código dentro de sí mismo, y cualquier código dentro de bucles, funciones y declaraciones if son otro bloque. Puede ver con la imagen de la derecha que hay cuatro niveles de bloques en ese script.

Entonces, ¿qué significa "local"? Bueno, significa que solo se puede acceder a la variable dentro de ese bloque. Esta palabra clave es similar a permitir JavaScript. Entonces, si tuviera que usar el siguiente código:

1 local db = falso 2 si db == falso entonces 3 local var = 1 4 end 5 print (var)

El script produciría un error, porque la declaración de impresión está intentando acceder a una variable a la que solo se puede acceder dentro de la declaración if.

1 local db = false 2 local var 3 si db == false entonces 4 var = 1 5 end 6 print (var)

Puede ver que en la segunda línea, no le he dado un valor a var, por lo tanto, se establece automáticamente en nil. Entonces, la instrucción if hará que var sea igual a 1. Ya no es 'local' porque la instrucción if simplemente está actualizando una variable ya existente.

Secuencias de comandos intermedias: ejemplos

Ladrillo multiusos para matar / curar (dificultad: media-dura)

¡Excelente! Ahora que tenemos nuestros conceptos definidos, empecemos. Digamos, queríamos un ladrillo que le quitara la cabeza a Shedletsky cada vez que lo pisaba, pero curaría a otros jugadores cuando lo pisaran. Entonces, cree un script y colóquelo dentro de un ladrillo usando el explorador.A continuación, creemos nuestra función que será llamada por el evento Touched y nuestro valor que será asignado por el evento Touched (para verificar si en realidad es Shedletsky, por supuesto !):

1 función táctil (shedletskycheck)

¡Excelente! Tenemos la función touch con el argumento shedletskycheck. Ahora tenemos que indicar qué hace nuestra función. Queremos que nuestra función primero verifique Shedletsky:

1 función toque (shedletskycheck) 2 '' 'si shedletskycheck.Parent.Name == "Shedletsky" entonces' ''

El guión ahora verifica si lo que tocó el nombre del padre del ladrillo era Shedletsky. Ahora debemos crear un camino que vaya desde el ladrillo conmovedor hasta la cabeza de Shedletsky:

1 función toque (shedletskycheck) 2 si shedletskycheck.Parent.Name == "Shedletsky" luego 3 shedletskycheck.Parent.Head: remove () 4 - Navegamos desde shedletskycheck a su padre, que es el modelo de Shedletsky, entonces encontramos la Cabeza dentro del modelo de Shedletsky.

Ahora, digamos que algo que NO FUE Shedletsky tocó el ladrillo. De acuerdo con la descripción de nuestro guión, debemos verificar si lo que tocó el ladrillo que no era Shedletsky era siquiera un jugador, entonces debemos curarlo. Como tal, debemos averiguar si el padre de la parte conmovedora tenía un humanoide. Para hacer esto, debemos usar un método; findFirstChild () (si no sabe qué es esto, consulte la guía para principiantes de secuencias de comandos).

Usando la instrucción elseif, si las condiciones para el "if" anterior (que es quien tocó el ladrillo siendo Shedletsky ") no se cumplen, entonces la instrucción elseif verifica la siguiente condición (en este caso, si el padre del ladrillo realmente tenía un Humanoid en él, que indica si lo que tocó el ladrillo era o no un jugador), y luego ejecutamos un método: findFirstChild () en el padre de la parte que toca, y si encuentra un Humanoide en el padre de la parte que toca, devuelve ~ = nil, sin embargo, si no encontró uno, devuelve nil.

Ahora, necesitamos curarlos:

1 función toque (shedletskycheck) 2 si shedletskycheck.Parent.Name == "Shedletsky" luego 3 shedletskycheck.Parent.Head: remove () 4 elseif shedletskycheck.Parent: findFirstchild ("Humanoid") ~ = nil luego 5 shedletskycheck.Parent. Salud humanoide = shedletsky.Parent.Humanoid.MaxHealth

Básicamente, esto establece el valor de su salud en su máxima salud, curándolos de manera efectiva a plena capacidad. ¡Hurra! Casi tenemos nuestro guión. Ahora todo lo que tenemos que hacer es agregar un "final" para cada "función" y "si" que tenemos, excluyendo "elseif".

1 función toque (shedletskycheck) 2 si shedletskycheck.Parent.Name == "Shedletsky" luego 3 shedletskycheck.Parent.Head: remove () 4 elseif shedletskycheck.Parent: findFirstChild ("Humanoid") ~ = nil luego 5 shedletskycheck.Parent. Humanoid.Health = shedletsky.Parent.Humanoid.MaxHealth 6 end 7 end

Tenemos una función y una si, excluyendo el "si" en "elseif", así que agregamos dos extremos.

Por último, necesitamos agregar la conexión:

1 función toque (shedletskycheck) 2 si shedletskycheck.Parent.Name == "Shedletsky" luego 3 shedletskycheck.Parent.Head: remove () 4 elseif shedletskycheck.Parent: findFirstChild ("Humanoid") ~ = nil luego 5 shedletskycheck.Parent. Humanoid.Health = shedletsky.Parent.Humanoid.MaxHealth 6 end 7 end 8 script.Parent.Touchched: conectar (tocar)

¡Hurra! Ahora, si ejecutamos nuestro guión en Play Solo, si le cambias el nombre a un personaje Shedletsky, cuando toque el ladrillo, ¡debería quitarle la cabeza! Sin embargo, si te dañas a ti mismo y tocas el ladrillo, ¡deberías recuperarte y recuperar la salud completa!

Extensión: efecto curativo extendido

Ahora digamos que no queríamos que nuestro ladrillo curara a otros jugadores instantáneamente, sino que los curaría en 20 cada 5 segundos 5 veces. Lo has adivinado: estamos usando bucles "for".

1 función toque (shedletskycheck) 2 si shedletskycheck.Parent.Name == "Shedletsky" luego 3 shedletskycheck.Parent.Head: remove () 4 elseif shedletskycheck.Parent: findFirstChild ("Humanoid") ~ = nil luego 5 para i = 1,5 , 6 hacer 7 terminar 8 terminar XNUMX script.Parent.Touchched: connect (touch)

Así que reemplazamos el código de curación inicial con un ciclo "for" que cuenta de 1 a 5 (de 1 a 5 veces), luego debemos agregar el código de curación para que el Humanoide gane 20 de salud extra (utilicé una variable para definir el humanoide en este caso para acortar el código, sin embargo, no es necesario) y agregue el método de espera que hace que el script espere 5 segundos antes de agregar más salud:

1 función toque (shedletskycheck) 2 si shedletskycheck.Parent.Name == "Shedletsky" luego 3 shedletskycheck.Parent.Head: remove () 4 elseif shedletskycheck.Parent: findFirstChild ("Humanoid") ~ = nil luego 5 para i = 1,5 , 6 do 5 espera (7) 8 b = shedletskycheck.Parent: findFirstChild ("Humanoid") 20 b.Health = b.Health + 9 10 end 11 end XNUMX script.Parent.Touchched: connect (touch)

Entonces agregamos una declaración de espera que hace que el script espere 5 segundos, luego, por supuesto, encontró el Humanoid y estableció su valor en su valor original más 20. (El valor de una variable no es constante, es lo que fuera cuando se estableció su valor. La variable no se actualiza continuamente. Por lo tanto:

1 a = 1 2 b = a 3 esperar (1) 4 a = 2 5 imprimir (b)

En realidad, mostraría 1, ya que en el momento en que b se estableció en a, a era 1, sin embargo, más tarde a se cambió a 2, pero dado que las variables no son constantes, b permaneció 1.)

Ahora, por último, debemos terminar el ciclo con un "fin":

1 función toque (shedletskycheck) 2 si shedletskycheck.Parent.Name == "Shedletsky" luego 3 shedletskycheck.Parent.Head: remove () 4 elseif shedletskycheck.Parent: findFirstChild ("Humanoid") ~ = nil luego 5 para i = 1,5 , 6 do 5 wait (7) 8 b = shedletskycheck.Parent: findFirstChild ("Humanoid") 20 b.Health = b.Health + 9 10 end 11 end 12 end XNUMX script.Parent.Touch: connect (touch)

Si hiciste esto correctamente, cuando pises el bloque con guión en Play Solo, si estás dañado, deberías ir ganando salud lentamente (a menos que tu nombre sea Shedletsky).

Extensión: efecto de desaparición

Ahora, digamos que queremos que nuestro guión aumente continuamente la transparencia de la cabeza de Shedletsky cada .1 segundo, y cuando la transparencia de su cabeza llegue a 1, SOLO ENTONCES el guión quitará la cabeza de Shedletsky. Vamos a utilizar algunos bucles "for" más. (Usé una variable para definir la transparencia de la cabeza de shedletsky, pero no es necesario)

1 función toque (shedletskycheck) 2 si shedletskycheck.Parent.Name == "Shedletsky" luego 3 trans = shedletskycheck.Parent.Head.Transparency 4 for i = 1,10 do 5 elseif shedletskycheck.Parent: findFirstChild ("Humanoid") ~ = cero luego 6 para i = 1,5 do 7 b = shedletskycheck.Parent: findFirstChild ("Humanoid") 8 b.Health = b.Health + 20 9 end 10 end 11 end 12 script.Parent.Touch: connect (touch )

Así que reemplazamos el código de configuración de transparencia básico con un bucle "for" que contaba de 1 a 10 y definía la transparencia de la cabeza de shedletsky como la variable trans. Ahora, debemos agregar la parte donde se incrementa su transparencia:

1 función toque (shedletskycheck) 2 si shedletskycheck.Parent.Name == "Shedletsky" luego 3 trans = shedletskycheck.Parent.Head.Transparency 4 for i = 1,10 do 5 trans = trans + 0.1 6 elseif shedletskycheck.Parent: findFirstChild ("Humanoid") ~ = nulo luego 7 para i = 1,5 do 8 b = shedletskycheck.Parent: findFirstChild ("Humanoid") 9 b.Health = b.Health + 20 10 end 11 end 12 end 13 script.Parent .Tocado: conectar (tocar)

Así que ahora esto aumentará la transparencia de la cabeza en 1 10 veces (un valor de transparencia de 1 hace que un ladrillo sea completamente invisible). Ahora tenemos que agregar la declaración que hace que el script espere .1 segundos entre aumentos de transparencia:

1 función toque (shedletskycheck) 2 si shedletskycheck.Parent.Name == "Shedletsky" luego 3 trans = shedletskycheck.Parent.Head.Transparencia 4 para i = 1,10 do 5 wait (0.1) 6 trans = trans + 0.1 7 elseif shedletskycheck.Parent: findFirstChild ("Humanoid") ~ = nil luego 8 para i = 1,5 do 9 b = shedletskycheck.Parent: findFirstChild ("Humanoid") 10 b.Health = b.Health + 20 11 end 12 end 13 final 14 script Padre Tocado: conectar (toque)

Por último, agregamos la declaración final:

1 función toque (shedletskycheck) 2 si shedletskycheck.Parent.Name == "Shedletsky" luego 3 trans = shedletskycheck.Parent.Head.Transparency 4 for i = 1,10 do 5 wait (0.1) 6 trans = trans + 0.1 7 end 8 elseif shedletskycheck.Parent: findFirstChild ("Humanoid") ~ = nil luego 9 para i = 1,5 do 10 b = shedletskycheck.Parent: findFirstChild ("Humanoid") 11 b.Health = b.Health + 20 12 end 13 end 14 end 15 script.Padre.Tocado: conectar (tocar)

Y la parte que le quita la cabeza a Shedletsky:

1 función toque (shedletskycheck) 2 si shedletskycheck.Parent.Name == "Shedletsky" luego 3 trans = shedletskycheck.Parent.Head.Transparency 4 for i = 1,10 do 5 wait (0.1) 6 trans = trans + 0.1 7 end 8 shedletskycheck.Parent.Head: remove () 9 elseif shedletskycheck.Parent: findFirstChild ("Humanoid") ~ = cero y luego 10 para i = 1,5 do 11 b = shedletskycheck.Parent: findFirstChild ("Humanoid") 12 b. Health = b.Health + 20 13 end 14 end 15 end 16 script.Parent.Touchched: connect (touch)

Así que ahora, cuando ejecutes el guión en Play Solo, si te nombras Shedletsky, cuando pises el ladrillo, tu cabeza debería desaparecer gradualmente hasta que mueras.

Grabación del jugador

Entonces, digamos que en este punto desea registrar a todos los jugadores que no son de Shedletsky que pisarán este ladrillo, para esto debemos usar una tabla:

1 t = {one} 2 función toque (shedletskycheck) 3 si shedletskycheck.Parent.Name == "Shedletsky" luego 4 trans = shedletskycheck.Parent.Head.Transparencia 5 para i = 1,10 do 6 espera (0.1) 7 trans = trans + 0.1 8 end 9 shedletskycheck.Parent.Head: remove () 10 elseif shedletskycheck.Parent: findFirstChild ("Humanoid") ~ = nil luego 11 para i = 1,5 do 12 b = shedletskycheck.Parent: findFirstChild (" Humanoide ") 13 b.Salud = b.Salud + 20 14 final 15 final 16 final 17 script.Padre.Tocado: conectar (tocar)

Hemos creado una tabla con el contenido "uno". Esto ayudará más adelante. A continuación, obtenga el número máximo de nuestra tabla utilizando el método table.maxn (), que devuelve el espacio más alto en la tabla:

1 t = {one} 2 función toque (shedletskycheck) 3 maxn = table.maxn (t) 4 si shedletskycheck.Parent.Name == "Shedletsky" luego 5 trans = shedletskycheck.Parent.Head.Transparency 6 para i = 1,10, 7 do 0.1 wait (8) 0.1 trans = trans + 9 10 end 11 shedletskycheck.Parent.Head: remove () 12 elseif shedletskycheck.Parent: findFirstChild ("Humanoid") ~ = nil luego 1,5 para i = 13 do 14 b = shedletskycheck.Parent: findFirstChild ("Humanoid") 20 b.Health = b.Health + 15 16 end 17 end 18 end XNUMX script.Parent.Touchched: connect (touch)

Ahora, debemos hacer que nuestra tabla inserte los nombres de los jugadores registrados usando el método table.insert () - table.insert (tabla, ubicación, valor):

1 t = {one} 2 función toque (shedletskycheck) 3 maxn = table.maxn (t) 4 si shedletskycheck.Parent.Name == "Shedletsky" luego 5 trans = shedletskycheck.Parent.Head.Transparency 6 para i = 1,10, 7 do 0.1 wait (8) 0.1 trans = trans + 9 10 end 11 shedletskycheck.Parent.Head: remove () 12 elseif shedletskycheck.Parent: findFirstChild ("Humanoid") ~ = nil luego 1,5 para i = 13 do 14 b = shedletskycheck.Parent: findFirstChild ("Humanoid") 20 b.Health = b.Health + 15 16 end 1 table.insert (t, (maxn - 17), shedletskycheck.Parent.Name) 18 end 19 end XNUMX script. Padre Tocado: conectar (tocar)

Lo que hace esto es que obtiene el lugar más alto en la tabla, lo resta por uno e inserta el valor del nombre allí. Hacemos esto para asegurarnos de que la tabla agregue un nuevo nombre en un nuevo espacio. Ahora, hagamos que imprima la tabla completa cuando se toca usando dos métodos: el método tostring y el método table.concat. El método table.concat básicamente toma todos los valores en una tabla y los aplasta. El método tostring convierte cualquier valor (como un valor de tabla) en un valor de cadena.

1 t = {one} 2 función toque (shedletskycheck) 3 maxn = table.maxn (t) 4 print (tostring (table.concat (t, ''))) 5 si shedletskycheck.Parent.Name == "Shedletsky" entonces 6 trans = shedletskycheck.Parent.Head.Transparency 7 for i = 1,10 do 8 wait (0.1) 9 trans = trans + 0.1 10 end 11 shedletskycheck.Parent.Head: remove () 12 elseif shedletskycheck.Parent: findFirstChild (" Humanoide ") ~ = nulo y luego 13 para i = 1,5 do 14 b = cheque shedletsky.Padre: findFirstChild (" Humanoide ") 15 b.Salud = b.Salud + 20 16 final 17 table.insert (t, (maxn - 1), shedletskycheck.Parent.Name) 18 end 19 end 20 script.Parent.Touchched: connect (touch)

La puerta VIP (dificultad: media)

Ahora digamos que querías un ladrillo que solo permitiera que una determinada persona lo atravesara, pero que matara a todos los demás. Crea un ladrillo, en primer lugar. Ponga un script en el ladrillo, luego abra su fuente. En primer lugar, debemos crear una función para ser llamada por el evento Touched y el valor que será definido por el evento Touched:

1 función onTouch (vip)

Entonces tenemos una función onTouch y un argumento "vip". A continuación, creamos una declaración "si" para comprobar si lo que tocó el ladrillo era un jugador llamado "Bob":

1 función onTouch (vip) 2 si vip.Parent.Name == "Bob" entonces

Nuestro script ahora verifica si el nombre del padre de lo que sea que tocó el ladrillo fue Bob. A continuación, dado que queremos que nuestro script permita que Bob pase, establecemos el valor del cancollide del ladrillo en "falso" durante 1 segundo. La propiedad CanCollide es la propiedad que hace que un ladrillo sea sólido.

1 función onTouch (vip) 2 si vip.Parent.Name == "Bob" entonces 3 script.Parent.CanCollide = falso 4 espera (1) 5 script.Parent.CanCollide = true

Nuestro guión ahora, cuando Bob lo toca, establece el CanCollide del ladrillo en falso, lo que le permite a Bob pasar, y después de 1 segundo, espere (1), establece el CanCollide del ladrillo en verdadero, sin dejar que otros pasen. Ahora, queremos que Bob sepa cuándo la puerta está abierta, así que haremos que el ladrillo sea semitransparente mientras que el CanCollide del ladrillo es falso:

Nuestro guión ahora, cuando lo toca Bob, no solo cambia el valor del CanCollide del ladrillo, sino que también lo hace semitransparente para que Bob sepa cuándo está abierta la puerta. Después de 1 segundo, espere (1), al mismo tiempo que CanCollide se establece en verdadero, la transparencia se establece en 0 para que Bob sepa cuándo se cierra la puerta. A continuación, agregamos la parte que verifica si (hablando hipotéticamente) lo que sea que tocó el bloque que NO ERA Bob era siquiera un jugador.

1 función onTouch (vip) 2 si vip.Parent.Name == "Bob" entonces 3 script.Parent.Transparency = 0.5 4 script.Parent.CanCollide = falso 5 espera (1) 6 script.Parent.Transparency = 0 7 script .Parent.CanCollide = true 8 elseif vip.Parent: findFirstChild ("Humanoid") ~ = nulo entonces

Entonces, si no se cumplen las condiciones para la primera declaración "si" (el tocador es Bob), entonces se realiza una verificación adicional que indica si el tocador era incluso un jugador. Ahora, la parte divertida: matar al jugador.

Entonces, nuestra declaración ahora establecerá la salud del humanoide encontrado en cero. Por último, cerremos nuestra "función" yo "si" (excluyendo nuestro "elseif")

Y por último, creemos la declaración de conexión (que hace que todo suceda :)

¡Felicidades! Si su guión funcionó, cualquiera llamado "Bob" debería poder pasar por la puerta, ¡pero cualquiera que no sea Bob será asesinado por la puerta! ¡Puedes cambiar "Bob" al nombre de tu agrado una vez que estés listo para implementar esto en tu lugar!

¡Eso es todo para la guía intermedia! Vaya a la guía avanzada de secuencias de comandos para continuar.