Share
Hola amigos. Lo más destacado de este tutorial es preciso Detección de golpe de un láser generado. Este tipo de IA es útil para hacer juegos de acción, especialmente en el caso de inteligencia de seguridad con cámaras, pistolas láser, etc. Así que pon tu cohete en la espalda, comienza la cuenta regresiva?
Echemos un vistazo al resultado final en el que trabajaremos:
Abra Flash y cree un nuevo documento de Flash (ActionScript 3.0).
Ajuste el tamaño del escenario a cualquier resolución estándar. El mío es de 500 x 350 px.
Establecer la velocidad de fotogramas a 24 fps.
Guarde el archivo en una carpeta de su elección.
Ahora vamos a crear un generador de láser..
Dibuja un círculo de radio 20, es decir, 40 x 40. Además, rellénalo con un bonito color de degradado radial.
Ahora necesitamos convertir este círculo en un símbolo de Flash para poder controlarlo con ActionScript.
Seleccione el círculo y presione F8 o vaya a Modificar> Convertir a símbolo. Seleccione Clip de película para el tipo de símbolo. También establezca el punto de registro en el centro para que el generador de láser gire desde su centro. Tipo laserGenerator_MC en el campo del nombre de la instancia y luego por último, pero no menos importante, marque "Exportar para ActionScript" en el grupo "Avanzado" para que podamos acceder al generador láser desde nuestra clase de documento, que nos reuniremos pronto.
Después de configurar todas las opciones anteriores, presione OK. Presione OK nuevamente para el cuadro de diálogo que muestra la advertencia para la definición de la clase. Esto creará una definición de clase para el generador láser en tiempo de ejecución.
Ahora no necesitamos laserGenerator_MC Símbolo en el escenario, ya que está disponible en el panel Biblioteca con el nombre del identificador laserGenerator_MC. Por lo tanto, elimine este símbolo del escenario. Tu escenario debería estar vacío ahora.
Ahora que agregaremos una boca a este generador para crear una sensación de dispositivo. En el panel de la biblioteca haz doble clic en laserGenerator_MC icono de símbolo (lado izquierdo del nombre del símbolo) para entrar en el modo de edición. Agregue boca a ella como se muestra abajo.
Siéntete libre de añadir tu propio diseño..
Nota: No cambie la posición del círculo ya que necesitamos girarlo alrededor de su centro.
Después de agregar una boca al generador, salga del modo de edición de símbolos y regrese a la línea de tiempo principal.
Tu cohete ha abandonado el suelo. El dispositivo generador de láser está listo y en espera de realizar.
Para agregar un drama a nuestra escena necesitamos ActionScript. Para actuar inteligentemente necesitamos clase de documentos..
En este paso crearemos una estructura básica de nuestra clase de documento..
Para una explicación detallada sobre la clase de documentos, consulte este Consejo rápido.
Así que crea un nuevo archivo de ActionScript 3.0. Escriba el siguiente código:
package public class Laser_HitDetection public function Laser_HitDetection () // código constructor
Guardar esta clase de documento como Laser_HitDetection.as en la misma carpeta donde guardó su FLA para este tutorial. Buen despegue Tu clase básica de documentos está lista..
En su archivo FLA, acceda al panel de Propiedades del documento y escriba el nombre de la clase en el campo Clase de documento disponible en el grupo "Publicar".
Ahora estamos listos para comunicarnos con FLA a través de este Laser_HitDetection.as clase de documento.
Crearemos una instancia de generador láser desde la biblioteca y la colocaremos en el centro del escenario..
Modificar el Laser_HitDetection.as clase de documento como se muestra a continuación (líneas resaltadas):
paquete import flash.display.Sprite; la clase pública Laser_HitDetection extiende Sprite var laserGun: Sprite; // Instancia de laserGenerator_MC // Constructor public function Laser_HitDetection () CreateLaserGun (); // Obtener y colocar el generador de láser de la biblioteca. Función pública CreateLaserGun (): void laserGun = new laserGenerator_MC (); // Obtenerlo de la biblioteca addChild (laserGun); // Coloca el generador de láser en el centro de la etapa laserGun.x = stage.stageWidth / 2; laserGun.y = stage.stageHeight / 2;
Si prueba la película ahora, verá nuestra pistola láser muy bien colocada en el centro del escenario..
Accentsconagua
CreateLaserGun () métodoEn el código anterior utilizamos Duende clase para crear una instancia de objeto Sprite que contendrá láser. Para eso declaramos variable como:
var laserGun: Sprite;
Luego agregamos un nuevo método "CreateLaserGun ()"en la que asignamos una instancia de laserGenerator_MC De la biblioteca a la anterior. pistola laser var como
laserGun = nuevo laserGenerator_MC ();
Después de agregarlo al escenario, lo colocamos en el centro del escenario como:
laserGun.x = stage.stageWidth / 2; laserGun.y = stage.stageHeight / 2;
Finalmente, llamamos a este método desde el método constructor de la clase de documento como:
// Función pública constructora Laser_HitDetection () CreateLaserGun ();
El cohete está acelerando con empuje completo. Muy pronto activaremos esta pistola láser que proyectará el láser. Antes de eso vamos a añadir algunos obstáculos. Vamonos.
Para experimentar con la detección de golpes necesitamos colocar algunos obstáculos en el escenario. Por lo tanto, en el escenario, dibuje diferentes formas que se asemejen a superficies cóncavas convexas, escalada de pendientes y bordes rectos, como se muestra a continuación:
Ahora pondremos todas estas formas en un símbolo. Seleccione todas las formas a la vez y presione F8 o vaya a Modificar> Convertir a símbolo. Seleccione Clip de película como el tipo de símbolo. Nombra este símbolo obstáculos_MC en el campo de texto del nombre. Establecer punto de registro en el centro. También marque "Exportar para ActionScript" para que podamos acceder a él desde nuestra clase de documento.
Después de convertir en MovieClip tenemos obstáculos_MC en la biblioteca con el mismo nombre identificador. Simlilary como laserGenerator_MC No necesitamos este símbolo en el escenario, así que elimínelo del escenario. Ahora tu escenario esta vacio.
La forma en que colocamos nuestro laserGenerator_MC en el escenario, en el centro, de manera similar colocaremos obstáculos_MC símbolo en el escenario. Modifique la clase de documento como se muestra a continuación:
paquete import flash.display.Sprite; la clase pública Laser_HitDetection extiende Sprite var laserGun: Sprite; // Instancia de laserGenerator_MC var obstáculos: Sprite; // Instancia de obstáculos_MC // Constructor función pública Laser_HitDetection () CreateLaserGun (); CreateObstacles (); // Obtener y colocar el generador de láser de la biblioteca. Función pública CreateLaserGun (): void laserGun = new laserGenerator_MC (); // Obtenerlo de la biblioteca addChild (laserGun); // Coloca el generador de láser en el centro de la etapa laserGun.x = stage.stageWidth / 2; laserGun.y = stage.stageHeight / 2; // Obtener y colocar obstáculos de la función pública de biblioteca CreateObstacles (): void obstáculos = nuevos obstáculos_MC (); // Consíguelo en la biblioteca addChild (obstáculos); // Coloca obstáculos en el centro de la etapa obstaculos.x = etapa.estadialAncho / 2; obstáculos.y = etapa.estataHeight / 2;
Prueba la película para ver los obstáculos colocados alrededor de la pistola láser..
Tu cohete está alcanzando velocidad terminal. Ahora es el momento de activar la pistola láser. Debe generar el láser a partir de él. Hagamos eso ahora.
¿Cómo vamos a imitar el láser? ¿¿Alguna conjetura?? ¿Qué tal usar algunos miembros de la clase de Gráficos como lineStyle (), mover a(), lineTo (). Si está familiarizado con estos métodos, entonces su trabajo es fácil. Para aquellos que no conocen estos métodos, siempre estamos con usted. Vamos a verlos en detalle..
Añadiremos un nuevo método. ProjectLaser (). Vamos a modificar nuestra Laser_HitDetection clase de documento como se muestra a continuación:
// Paquete de constructor import flash.display.Sprite; la clase pública Laser_HitDetection extiende Sprite var laserGun: Sprite; // Instancia de laserGenerator_MC var obstáculos: Sprite; // Instancia de obstáculos_MC var laser: Sprite; var startX: Number; // x punto de inicio del láser var startY: Number; // y punto de inicio del láser var endX: Número; // x punto final del láser var endY: Número; // y punto final del láser // Constructor public function Laser_HitDetection () CreateLaserGun (); CreateObstacles (); ProjectLaser (); // Obtener y colocar el generador de láser de la biblioteca. Función pública CreateLaserGun (): void laserGun = new laserGenerator_MC (); // Obtenerlo de la biblioteca addChild (laserGun); // Coloca el generador de láser en el centro de la etapa laserGun.x = stage.stageWidth / 2; laserGun.y = stage.stageHeight / 2; // Obtener y colocar obstáculos de la función pública de biblioteca CreateObstacles (): void obstáculos = nuevos obstáculos_MC (); // Consíguelo en la biblioteca addChild (obstáculos); // Coloca obstáculos en el centro de la etapa obstaculos.x = etapa.estadialAncho / 2; obstáculos.y = etapa.estataHeight / 2; // Proyectar un láser desde la función pública del dispositivo generador de láser ProjectLaser (): void laser = new Sprite (); addChild (láser); // Establecer el origen del láser como el centro de la pistola láser startX = laserGun.x; startY = laserGun.y; // Establecer el punto final del láser endX = startX + 230; endY = startY; // Draw laser laser.graphics.lineStyle (1, 0xFF0000); laser.graphics.moveTo (startX, startY); laser.graphics.lineTo (endX, endY);
Prueba la pelicula.
El cohete está ahí arriba en el cielo. La pistola láser ha comenzado a proyectar el láser. ¿Cómo ocurrió eso? Intentemos entender el código anterior en el siguiente paso.
En el paso anterior proyectamos con éxito un láser. Para eso realizamos las siguientes tareas:
En primer lugar, declaramos cinco nuevas variables:
láser var: Sprite; var startX: Number; // x punto de inicio del láser var startY: Number; // y punto de inicio del láser var endX: Número; // x punto final del láser var endY: Número; // y punto final del láser
Segundo, agregamos un nuevo método. ProjectLaser ():
función pública ProjectLaser (): void laser = new Sprite (); addChild (láser); // Establecer el origen del láser como el centro de la pistola láser startX = laserGun.x; startY = laserGun.y; // Establecer el punto final del láser endX = startX + 230; endY = startY; // Draw laser laser.graphics.lineStyle (1, 0xFF0000); laser.graphics.moveTo (startX, startY); laser.graphics.lineTo (endX, endY);
ProjectLaser () MétodoEn el método anterior, primero creamos un objeto Sprite vacío para sostener el láser y también lo agregamos al escenario como se muestra a continuación:
láser = nuevo Sprite (); addChild (láser);
Como queríamos que el láser comenzara a proyectar desde la pistola láser, asignamos el valor X de la pistola láser a inicioX y el valor de Y para inicioY Como se muestra abajo:
startX = laserGun.x; startY = laserGun.y;
(Posteriormente proporcionamos estos valores a la moveTo (startX, startY) método que vamos a encontrar pronto.)
Entonces definimos endX y fin:
endX = startX + 230; endY = startY;
Los valores asignados a las variables anteriores son valores temporales. Los usamos solo para mostrar la proyección básica de un láser. En los próximos pasos modificaremos estos valores aplicando algunos cálculos simples. Estos valores son clave para hacer una detección perfecta del láser. Los estudiaremos más adelante en esta sesión..
Y ahora la parte importante de este método. Dibujar una línea recta dentro del objeto sprite láser para imitar el láser proyectado.
Primero manejamos el estilo de la línea a dibujar como se muestra a continuación:
laser.graphics.lineStyle (1, 0xFF0000);
Este método lineStyle () se usa para controlar el estilo del trazo del objeto de dibujo, como una línea, un rectángulo, un óvalo, etc. Puede proporcionar un máximo de ocho argumentos para este método. Si no se especifican valores predeterminados se asignan en su lugar. Para nuestro ejemplo solo necesitamos dos argumentos. El primer argumento es el grosor de la línea (es decir, 1) y el segundo argumento es el color de la línea (es decir,. 0xFF0000, que es rojo).
Para obtener una explicación detallada de este método, consulte el documento de ayuda de Adobe sobre el método "lineStyle (args?)".
Luego colocamos el punto de inicio de la línea como se muestra a continuación:
laser.graphics.moveTo (startX, startY);
inicioX y inicioY Asegura que el punto de partida debe ser el centro de la pistola láser..
Después de eso terminamos la línea:
laser.graphics.lineTo (endX, endY);
Recuerde que estos endX y endY son valores temporales solo para mostrar la proyección. Necesitamos que se ajusten si hay algún obstáculo en el camino del láser. Vamos a hacer esas matemáticas en los próximos pasos..
Entonces, trazamos una línea deinicioX, inicioY) a (endX, fin).
El cohete va y va. Ver esos paisajes, paisajes acuáticos.?
Ahora es el momento de la acción real. Detección de golpes con obstáculos..
Ahora, estamos equipados con una pistola láser. También tenemos varios obstáculos. Estamos en el nivel en el que podemos agregar detección de golpes, lo que sin duda agregará el significado a la escena..
Podría estar pensando que esta detección de golpes altamente precisa requerirá cálculos complejos. Si es así, estás equivocado. Simplemente utiliza el método hitTestPoint () integrado en ActionScript junto con un para lazo. La matemática compleja detrás de la detección de golpes perfecta se maneja con este método. Solo necesitas utilizar este método y un para bucle de una manera inteligente.
Vamos a hacer algunos cambios importantes en nuestra clase de documentos principalmente para ProjectLaser () Método y algunos vars nuevos, así que observa y aplícalo cuidadosamente. Vamos a modificarlo como se muestra:
Primero agregue estos nuevos vars:
var rad: Number = Math.PI / 180; // Se usa para calcular el ángulo en radianes var maxDist: Number = 250; // distancia máxima a recorrer por el láser var ajustDist: Number; // nueva distancia máxima si cualquier obstáculo viene de alguna manera
Luego modificar ProjectLaser () método añadiendo para bucle como se muestra a continuación (también tenga en cuenta que ahora endX y fin están dentro para lazo):
// Proyectar un láser desde la función pública del dispositivo generador de láser ProjectLaser (): void laser = new Sprite (); addChild (láser); // Establecer el origen del láser como el centro de la pistola láser startX = laserGun.x; startY = laserGun.y; para (selectedDist = 0; adjustDist < maxDist; adjustedDist ++) //Trigonometry to aim the laser w.r.t laser gun's rotation endX = laserGun.x + Math.cos ( laserGun.rotation * rad ) * adjustedDist; endY = laserGun.y + Math.sin ( laserGun.rotation * rad ) * adjustedDist; //calculate hit test if ( obstacles.hitTestPoint ( endX, endY, true ) ) break; //Draw laser laser.graphics.lineStyle( 1, 0 x FF0000 ); laser.graphics.moveTo( startX, startY ); laser.graphics.lineTo ( endX, endY );
Prueba la pelicula.
Auge? Estoy seguro. Mirando este efecto, estás inspirado para crear un Juego Flash con inteligencia de seguridad. Perfect AI, para desarrollar un juego interesante en Flash..
En primer lugar, agregamos nuevos vars a nuestra clase de documento como se muestra:
Inicialmente, un ángulo, en radianes.
var rad: Number = Math.PI / 180; // Se usa para calcular el ángulo en radianes
La var anterior se usa en la fórmula para calcular un ángulo en radianes.
La formula es, radianes = grados * Matemáticas.PI / 180. Más información aquí. Usamos esta fórmula en nuestro código, en estas líneas:
endX = laserGun.x + Math.cos (laserGun.rotation * rad) * adjustDist; endY = laserGun.y + Math.sin (laserGun.rotation * rad) * adjustDist;
En laserGun.rotation * rad, grados = laserGun.rotation, y rad = Matemáticas.PI / 180.
En segundo lugar, creamos una var para la distancia máxima que debe recorrer el láser:
var maxDist: Número = 250; // Distancia máxima a recorrer por el láser
Esta var decide la distancia máxima a recorrer por el láser. Dado que no es necesario dibujar el láser más allá del área visible, definimos un buen punto final. Esta var hará lo que sea necesario..
Tercero, tenemos una var para la distancia actual del láser en el momento de la intersección con cualquier obstáculo.
var adjustDist: Number; // nueva distancia máxima si cualquier obstáculo viene de alguna manera
Cuando cualquier obstáculo se interpone en el camino del láser, el láser se bloquea en lugar de viajar a la distancia máxima.
La distancia después de bloquear un láser no es más que la distancia ajustada dependiendo de la situación.
los para bucle y hitTestPoint () Cada uno juega un papel importante en el cálculo de esta distancia..
Cuarto, modificamos ProjectLaser () método mediante la adición de ActionScript hitTestPoint () junto con un para lazo. Fueron asignados endX y fin variables.
para (selectedDist = 0; adjustDist < maxDist; adjustedDist ++) //Trigonometry to aim the laser w.r.t laser gun's rotation endX = laserGun.x + Math.cos ( laserGun.rotation * rad ) * adjustedDist; endY = laserGun.y + Math.sin ( laserGun.rotation * rad ) * adjustedDist; //calculate hit test if ( obstacles.hitTestPoint ( endX, endY, true ) ) break;
El bucle for asegura que la distancia ajustada se aumentará hasta la distancia máxima. Podría estar pensando "¿Cuál es la diversión de hacer que la distancia ajustada sea igual a la distancia máxima?"
En realidad, esta distancia ajustada puede coincidir con la distancia máxima de forma natural, pero tan pronto como llegue a cualquier obstáculo (que es detectado por hitTestPoint () método) esta distancia se marca como distancia máxima para esa situación actual. Gracias a hitTestPoint () por hacer la tarea tan simple.
También reasignamos endX y fin valores como:
endX = laserGun.x + Math.cos (laserGun.rotation * rad) * adjustDist; endY = laserGun.y + Math.sin (laserGun.rotation * rad) * adjustDist;
Las funciones de trigonometría. Math.cos () y Math.sin () Se utilizan para calcular el ángulo de rotación de la pistola láser con láser..
En forma simple, se encarga de apuntar el láser hacia donde mira la pistola láser. Es importante que la pistola láser y el láser estén sincronizados. Así que cada vez que se gira la pistola láser, el láser seguirá la rotación.
Para obtener más información sobre la trigonometría, lea este Consejo rápido.
Finalmente el clímax de la escena:
if (obstaculos.hitTestPoint (endX, endY, true)) break;
hitTestPoint () El método toma tres parámetros, de los cuales el primero y el segundo son necesarios y el tercero (shapeFlag) se dejará como predeterminado (es decir,. falso) si no se especifica.
En nuestro ejemplo, shapeFlag se establece en cierto ya que queremos la detección de golpes con respecto a la forma exacta del objeto objetivo (es decir,. obstáculos). Si este valor se establece en falso la detección de impactos se produce con respecto al cuadro delimitador de ese objeto y no a la forma exacta.
Los primeros y segundos parámetros de hitTestPoint () defina un punto (x, y) en el que comprobar la intersección con el objeto de visualización. En nuestro caso obstáculos es ese objeto de visualización, y endX y fin Representa el punto de intersección en el escenario..
¿Poco claro? Derecha. Para simplificar vamos a poner la lógica en secuencia de la siguiente manera:
para el bucle permite que la proyección del láser continúe (actualizando endX y fin) si está dentro de la distancia máxima.hitTestPoint () está esperando para romper el para Bucle tan pronto como vea la intersección. Una vez el para el bucle está roto, endX y fin están congelados.endX y fin se pasan a la graphics.lineTo () método.Para agregar rotación a la pistola láser debemos realizar algunos cambios importantes:
ProjectLaser () método.HitTest ().laser.graphics.clear () en el para lazo.import flash.events.Event Primero reestructuraremos el ProjectLaser () Método cambiando toda la lógica de detección de golpes en un nuevo método HitTest ().
Luego añadiremos laser.graphics.clear () declaración antes laser.graphics.lineStyle (1, 0xFF0000) declaración dentro de la para bucle de nuevo método HitTest (). Esto eliminará la vieja proyección del láser de la etapa cuando la pistola láser comience a girar.
Veamos cómo se verá después de hacer los cuatro cambios principales:
función pública ProjectLaser (): void laser = new Sprite (); addChild (láser); // Establecer el origen del láser como el centro de la pistola láser startX = laserGun.x; startY = laserGun.y; // Función pública de prueba de golpe HitTest (): void for (adjustDist = 0; adjustDist < maxDist; adjustedDist ++) //Trigonometry to aim the laser w.r.t laser gun's rotation endX = laserGun.x + Math.cos(laserGun.rotation * rad) * adjustedDist; endY = laserGun.y + Math.sin(laserGun.rotation * rad) * adjustedDist; //calculate hit test if (obstacles.hitTestPoint(endX,endY,true)) break; //Draw laser laser.graphics.clear(); //Removes the old laser projection laser.graphics.lineStyle( 1, 0xFF0000 ); laser.graphics.moveTo( startX, startY ); laser.graphics.lineTo ( endX, endY );
Usted podría preguntarse por qué hicimos cambios tan importantes? La unica razon es ENTER_FRAME evento.
Para aplicar rotación continua añadiremos un nuevo método., LaserGunRotation (evt: Evento) que es activado por ENTER_FRAME evento (lo que significa que se ejecuta 24 veces por segundo, ya que nuestra velocidad de fotogramas es de 24 fps). Cuando se usa este evento, debe tener cuidado de agregar solo aquellas propiedades que queremos cambiar durante un período de tiempo. Evitar poner en esos valores que permanecen constantes durante toda la ejecución..
En nuestro caso, si se observa viejo. ProjectLaser () método, tiene:
láser = nuevo Sprite (); addChild (láser); // Rotar pistola láser
Imagínese si agrega las declaraciones anteriores en un método que utiliza ENTER_FRAME evento; luego se crearía un nuevo objeto de láser Sprite y se agregaría al escenario repetidamente, 24 veces por segundo.
Esto es absolutamente innecesario. Por eso hemos reestructurado ProjectLaser () método y nuevo método añadido HitTest (). Puedes renombrar ProjectLaser () método para InitializeLaser () Ya que ya no proyecta el láser. Ahora solo crea el soporte vacío para el láser y define su punto de inicio. La proyección se maneja en un nuevo método., HitTest ().
Ahora veamos el nuevo método. LaserGunRotation (evt: Evento). Antes de eso, agregue la siguiente declaración de importación al inicio de la clase de documento:
import flash.events.Event;
Y añada el siguiente método:
// Rotar la función pública de la pistola láser LaserGunRotation (evt: Event): void laserGun.rotation + = 0.5; HitTest ();
Además, no olvides llamar a este método con un ENTER_FRAME evento dentro de la función del constructor como se muestra a continuación:
// Función pública constructora Laser_HitDetection () CreateLaserGun (); CreateObstacles (); ProjectLaser (); addEventListener (Event.ENTER_FRAME, LaserGunRotation);
Esto lo configura para ejecutar el LaserGunRotation () funciona 24 veces por segundo.
Prueba la pelicula.
El cohete ya ha penetrado en las nubes. Ver la hermosa tierra.
En este paso agregaremos un control para ajustar la precisión de la detección de impacto. Esto es importante ya que no necesita la detección precisa de golpes cada vez; Es posible que necesite un nivel promedio de detección de golpes. Esto también ayudará a reducir el consumo de CPU en el momento de la detección de aciertos..
Introduciremos una nueva variable. tolerancia como:
tolerancia var: Número = 1;
Luego modificaremos la para declaración de incremento del bucle como:
para (selectedDist = 0; adjustDist < maxDist; adjustedDist += tolerance)
Ahora el bucle for se verá como:
para (selectedDist = 0; adjustDist < maxDist; adjustedDist += tolerance) //Trigonometry to aim the laser w.r.t laser gun's rotation endX = laserGun.x + Math.cos(laserGun.rotation * rad) * adjustedDist; endY = laserGun.y + Math.sin(laserGun.rotation * rad) * adjustedDist; //calculate hit test if (obstacles.hitTestPoint(endX,endY,true)) break;
Esto significa que, en lugar de verificar una colisión en cada píxel de la línea de láser, solo estamos comprobando una colisión en cada píxel o en cada tercer píxel, etc..
La reducción del valor de "tolerancia" aumentará la precisión de la detección de aciertos, pero requerirá más potencia de la CPU. Intenta experimentar con diferentes valores para la "tolerancia".
Amigos, es hora de dejar el cohete y abrir el paracaídas. Aterrice de forma segura en el suelo y comience a usar la técnica anterior en sus juegos y aplicaciones Flash. Disfrutar!
En este tutorial vimos principalmente la perfecta utilización de hitTestPoint () y un para bucle para crear una detección precisa de golpes sin utilizar ningún cálculo matemático complejo.
Este efecto se puede utilizar en un juego de acción de tipo de seguridad donde se requieren cámaras y pistolas láser.
