¡Bienvenido a Universo Maker!
¿Es esta la primera vez que visitas el foro? Si es así te recomendamos que te registres para tener completo acceso a todas las áreas y secciones del foro, así también podrás participar activamente en la comunidad. Si ya tienes una cuenta, conectate cuanto antes.
Iniciar Sesión Registrarme

No estás conectado. Conéctate o registrate

Ver el tema anterior Ver el tema siguiente Ir abajo Mensaje [Página 1 de 1.]

#1 | MV | Ultimate Sensor Event 1.1 el Dom Nov 20, 2016 2:23 am

Reputación del mensaje :100% (4 votos)

Faye Valentine

avatar

ULTIMATE SENSOR EVENT 
RPG Maker MV
Creado por Reshi, editado por Faye Valentine 
Sobre el Plugin
Este plugin te permitirá el evaluar en tiempo real si el jugador está a X rango de un evento. Por ejemplo, queremos crear un guardia que tenga 4 tiles de línea de visión, y que al vernos nos empiece a perseguir. Hacer esto por engines es un tedio y es allí donde entra esta maravilla de plugin, que nos permite hacerlo todo mediante un solo comando. Podremos especificar además el tipo de visión, dando ejemplos rápidos podemos conseguir: línea, área, circular, diagonalmente, arriba de, a la izquierda de, a la derecha de, encima de, detrás de, entre otros.

Sin embargo este plugin traía consigo una pega muy grande, y es que solo era capaz de evaluar la posición de un evento en relación con el jugador, ¡pero allí es donde entro yo!

He editado este plugin para que sea capaz de evaluar la posición relativa de un evento con otro. ¿No está genial? Este plugin nos abre muchas posibilidades.
Imágenes:
No visible mediante imagenes.
Instrucciones:
Instrucciones en el apartado de ayuda del plugin.
Código:

¡Clickéame!

Código:
//=============================================================================
// Ultimate Sensor Event
// By Kvothe
// UltimateSensorEvent.js
// Version: 1.2.1
// Free for commercial and non commercial use.
//=============================================================================
var Imported = Imported || {};
var Kvothe = Kvothe || {};
Kvothe.UltimateSensorEvent = {};
//*_________________________________________________________________________________
// English:Plugin
//*_________________________________________________________________________________
/*:
* @author Kvothe
* @plugindesc  Añade sistema de sensores para tu juego de múltiples maneras. Traducción y edición: Faye Valentine.
* @help
* Contacto con el autor:
*     website http://www.dax-soft.weebly.com
* Contacto con el editor del script:
*     website http://www.universomaker.net/u41
*_________________________________________________________________________________
* Utilizar los comandos en Condiciones y Efectos / Conditional Branch ; como evaluar Script.
*_________________________________________________________________________________
* Valores:
*     distance : Distancia en tiles.
*     id: ID del evento.
*     id2: ID del evento que evaluará el primer ID.
*     E.J: ID evaluará si ID2 está a 2 tiles en línea recta de el.
*_________________________________________________________________________________
* this.sArea(distance, id)  Revisa en forma de área (cuadro)
* this.sUnder(distance, id) Revisa si está debajo
* this.sOver(distance, id) Revisa si está arriba
* this.sLeft(distance, id) Revisa si está a la izquierda
* this.sRight(distance, id) Revisa si está a la derecha
* this.sAbove(id) Revisa si está encima
* this.sCross(distance, id) Revisa en forma de cruz (arriba-abajo-izquierda-derecha)
* this.sTarget(distance, id) Revisa en línea de visión (a donde esté mirando)
* this.sBehind(distance, id) Revisa si está justo detrás
* this.vLeft(distance, id) Revisa si está justo a la izquierda
* this.vRight(distance, id) Revisa si está justo a la derecha
* this.dUpperRight(distance, id) Revisa si está arriba a la derecha (diagonal)
* this.dUpperLeft(distance, id) Revisa si está arriba a la izquierda (diagonal)
* this.iBelowRight(distance, id) Revisa si está abajo a la derecha (diagonal)
* this.iBelowLeft(distance, id) Revisa si está abajo a la izquierda (diagonal)
* this.sDiagonal(distance, id) Revisa si está en cualquier punto diagonal
* this.vTargetDiagonal(distance, id) Revisa si está en un punto diagonal con relación a la línea de visión (e.j: si mira abajo: abajo-izquierda y abajo-derecha)
* this.sPerimeter(distance, id) Revisa en forma de círculo
*_________________________________________________________________________________
*                           FAYE VALENTINE EDIT
*_________________________________________________________________________________
* this.sAreaEV(distance, id, id2)
* this.sUnderEV(distance, id, id2)
* this.sOverEV(distance, id, id2)
* this.sLeftEV(distance, id, id2)
* this.sRightEV(distance, id, id2)
* this.sAboveEV(id, id2)
* this.sCrossEV(distance, id, id2)
* this.sTargetEV(distance, id, id2)
* this.sBehindEV(distance, id, id2)
* this.vLeftEV(distance, id, id2)
* this.vRightEV(distance, id, id2)
* this.dUpperRightEV(distance, id, id2)
* this.dUpperLeftEV(distance, id, id2)
* this.iBelowRightEV(distance, id, id2)
* this.iBelowLeftEV(distance, id, id2)
* this.sDiagonalEV(distance, id, id2)
* this.vTargetDiagonalEV(distance, id, id2)
* this.sPerimeterEV(distance, id, id2)
*_____________________________________________________________________________
* Atención : las llamadas sUnder, sOver, sLeft y sRight son estáticas. Estarán fijadas independientemente de la dirección del evento.
* Las llamadas sTarget, sBehind, vLeft y vRight sí determinarán la dirección del evento.
*
* Para revisar un evento en vez del jugador, utilizar EV después del nombre del comando, como se muestra en la lista. E.j: this.sTargetEV
*_________________________________________________________________________________
*/
  
(function($) {
  'use strict';
  /**
   * Retorna ao setting do evento.
   *
   * @method eventMap
   * @param eventId {Number} O ID do evento.
   * @param defaultEventID {Number} ID do evento padrão.
   * @return {Object} : Retorna ao objeto da classe do Evento.
   */
  $.eventMap = function(eventId, defaultEventID) {
    return $gameMap.event(eventId == null ? Number(defaultEventID) : Number(eventId));
  }
  
  
  $.eventMap2 = function(eventId2, defaultEventID) {
    return $gameMap.event(eventId2 == null ? Number(defaultEventID) : Number(eventId2));
  }
  
  
  /**
   * Verifica em forma de área(bloco).
   *
   * @method sArea
   * @param distance {Number} Distância.
   * @param eventId {Number} ID do evento.
   * @return {Boolean}
   */
  Game_Interpreter.prototype.sArea = function(distance, eventId) {
    var _event = $.eventMap(eventId, this._eventId);
    return ( ( Math.abs($gamePlayer.x - _event.x) + Math.abs($gamePlayer.y - _event.y) ) <= Math.abs(distance) );
  };
  
  
  
    /**
   * Verifica em forma de área para eventos.
   *
   * @method sAreaEV
   * @param distance {Number} Distância.
   * @param eventId {Number} ID do evento.
   * @param eventId2 {Number} ID do evento 2.
   * @return {Boolean}
   */
  Game_Interpreter.prototype.sAreaEV = function(distance, eventId, eventId2) {
    var _event = $.eventMap(eventId, this._eventId);
 var _eventar = $.eventMap2(eventId2, this._eventId2);
    return ( ( Math.abs(_eventar.x - _event.x) + Math.abs(_eventar.y - _event.y) ) <= Math.abs(distance) );
  };
  
  
  /**
   * Verifica se está em cima do evento.
   *
   * @method sAbove
   * @param eventId {Number} ID do evento.
   * @return {Boolean}
   */
  Game_Interpreter.prototype.sAbove = function(eventId) {
    // body...
    var _event = $.eventMap(eventId, this._eventId);
    if ( $gamePlayer.x == _event.x && $gamePlayer.y == _event.y ) return true;
    return false;
  };
  
  
    /**
   * Verifica se evento está em cima do evento.
   *
   * @method sAboveEV
   * @param eventId {Number} ID do evento.
   * @return {Boolean}
   */
  Game_Interpreter.prototype.sAboveEV = function(eventId, eventId2) {
    // body...
    var _event = $.eventMap(eventId, this._eventId);
 var _eventar = $.eventMap2(eventId2, this._eventId2);
    if ( _eventar.x == _event.x && _eventar.y == _event.y ) return true;
    return false;
  };

  
  /**
   * Verifica se está ao lado direito do evento.
   *
   * @method sRight
   * @param distance {Number} Distância.
   * @param eventId {Number} ID do evento.
   * @return {Boolean}
   */
  Game_Interpreter.prototype.sRight = function (distance, eventId) {
    // body...
    var _event = $.eventMap(eventId, this._eventId);
    if ($gamePlayer.y == _event.y) {
      for (var i = _event.x + 1; i < _event.x + Math.abs(distance); i++) {
        if (!$gameMap.isPassable(i, _event.y, 6)) break;
        if ($gamePlayer.x == i) return true;
      }
    }
    return false;
  };
  
  
 
   /**
   * Verifica se está ao lado direito do evento.
   *
   * @method sRightEV
   * @param distance {Number} Distância.
   * @param eventId {Number} ID do evento.
   * @return {Boolean}
   */
  Game_Interpreter.prototype.sRightEV = function (distance, eventId, eventId2) {
    // body...
    var _event = $.eventMap(eventId, this._eventId);
 var _eventar = $.eventMap(eventId2, this._eventId);
    if (_eventar.y == _event.y) {
      for (var i = _event.x + 1; i < _event.x + Math.abs(distance); i++) {
        if (!$gameMap.isPassable(i, _event.y, 6)) break;
        if (_eventar.x == i) return true;
      }
    }
    return false;
  };
 
 
 
  
  
  /**
   * Verifica se está ao lado esquerdo do evento.
   *
   * @method sLeft
   * @param distance {Number} Distância.
   * @param eventId {Number} ID do evento.
   * @return {Boolean}
   */
  Game_Interpreter.prototype.sLeft = function (distance, eventId) {
    // body...
    var _event = $.eventMap(eventId, this._eventId);
    if ($gamePlayer.y == _event.y) {
      for (var i = _event.x + 1; i < _event.x + Math.abs(distance); i++) {
        if (!$gameMap.isPassable(i, _event.y, 6)) break;
        if ($gamePlayer.x == i - distance) return true;
      }
    }
    return false;
  };
  
  
  
    /**
   * Verifica se está ao lado esquerdo do evento.
   *
   * @method sLeftEV
   * @param distance {Number} Distância. / FAYE INPUT: empieza desde 0,0 el conteo. Para 3, 4. Para 5, 6. Etc.
   * @param eventId {Number} ID do evento.
   * @return {Boolean}
   */
  Game_Interpreter.prototype.sLeftEV = function (distance, eventId, eventId2) {
    // body...
    var _event = $.eventMap(eventId, this._eventId);
 var _eventar = $.eventMap(eventId2, this._eventId);
    if (_eventar.y == _event.y) {
      for (var i = _event.x + 1; i < _event.x + Math.abs(distance); i++) {
        if (!$gameMap.isPassable(i, _event.y, 6)) break;
        if (_eventar.x == i - distance) return true;
      }
    }
    return false;
  };
  
  
  
  /**
   * Verifica se está atrás do evento.
   *
   * @method sOver
   * @param distance {Number} Distância.
   * @param eventId {Number} ID do evento.
   * @return {Boolean}
   */
  Game_Interpreter.prototype.sOver = function (distance, eventId) {
    // body...
    var _event = $.eventMap(eventId, this._eventId);
    if (($gamePlayer.x == _event.x)) {
      for (var i = _event.y; i > _event.y - distance-1; i--) {
        if ($gameMap.isPassable(_event.x, i, 8))
          if ($gamePlayer.y == i) return true;
      }
    }
    return false;
  };
  
  
  
  /**
   * Verifica se está atrás do evento.
   *
   * @method sOverEV
   * @param distance {Number} Distância.
   * @param eventId {Number} ID do evento.
   * @return {Boolean}
   */
  Game_Interpreter.prototype.sOverEV = function (distance, eventId, eventId2) {
    // body...
    var _event = $.eventMap(eventId, this._eventId);
 var _eventar = $.eventMap(eventId2, this._eventId);
    if ((_eventar.x == _event.x)) {
      for (var i = _event.y; i > _event.y - distance-1; i--) {
        if ($gameMap.isPassable(_event.x, i, 8))
          if (_eventar.y == i) return true;
      }
    }
    return false;
  };
  
  
  /**
   * Verifica se está em frente ao evento.
   *
   * @method sUnder
   * @param distance {Number} Distância.
   * @param eventId {Number} ID do evento.
   * @return {Boolean}
   */
  Game_Interpreter.prototype.sUnder = function (distance, eventId) {
    // body...
    var _event = $.eventMap(eventId, this._eventId);
    if (($gamePlayer.x == _event.x)) {
      for (var i = _event.y; i > _event.y - distance; i--) {
        if ($gameMap.isPassable(_event.x, i, 8))
          if ($gamePlayer.y == (i+(distance))-1) return true;
      }
    }
    return false;
  };
  
  
  
   /**
   * Verifica se está em frente ao evento.
   *
   * @method sUnderEV
   * @param distance {Number} Distância.
   * @param eventId {Number} ID do evento.
   * @return {Boolean}
   */
  Game_Interpreter.prototype.sUnderEV = function (distance, eventId, eventId2) {
    // body...
    var _event = $.eventMap(eventId, this._eventId);
 var _eventar = $.eventMap2(eventId2, this._eventId2);
    if ((_eventar.x == _event.x)) {
      for (var i = _event.y; i > _event.y - distance; i--) {
        if ($gameMap.isPassable(_event.x, i, 8))
          if (_eventar.y == (i+(distance))-1) return true;
      }
    }
    return false;
  };
  
  
  
  /**
   * Verifica em forma de cruz.
   *
   * @method sCross.
   * @param distance {Number} Distância.
   * @param eventId {Number} ID do evento.
   * @return {Boolean}
   */
  Game_Interpreter.prototype.sCross = function (distance, eventId) {
    // body...
    return ( this.sUnder(distance, eventId) || this.sOver(distance, eventId) ||
             this.sRight(distance, eventId) || this.sLeft(distance, eventId))
  };
  
  
   /**
   * Verifica em forma de cruz.
   *
   * @method sCrossEV.
   * @param distance {Number} Distância.
   * @param eventId {Number} ID do evento.
   * @return {Boolean}
   */
  Game_Interpreter.prototype.sCrossEV = function (distance, eventId, eventId2) {
    // body...
    return ( this.sUnderEV(distance, eventId, eventId2) || this.sOverEV(distance, eventId, eventId2) ||
             this.sRightEV(distance, eventId, eventId2) || this.sLeftEV(distance, eventId, eventId2))
  };
  
  
  /**
   * Verifica de acordo com a visão do evento.
   *
   * @method sTarget
   * @param distance {Number} Distância.
   * @param eventId {Number} ID do evento.
   * @return {Boolean}
   */
   Game_Interpreter.prototype.sTarget = function (distance, eventId) {
     // body...
     switch  ( ($.eventMap(eventId, this._eventId)).direction() ) {
       case 2:
         return this.sUnder(distance, eventId);
       case 4:
         return this.sLeft(distance, eventId);
       case 6:
         return this.sRight(distance, eventId);
       case 8:
         return this.sOver(distance, eventId);
       default:
         break;
     }
   };
  
  
  
     /**
   * Verifica de acordo com a visão do evento.
   *
   * @method sTargetEV
   * @param distance {Number} Distância.
   * @param eventId {Number} ID do evento.
   * @return {Boolean}
   */
   Game_Interpreter.prototype.sTargetEV = function (distance, eventId, eventId2) {
     // body...
     switch  ( ($.eventMap(eventId, this._eventId)).direction() ) {
       case 2:
         return this.sUnderEV(distance, eventId, eventId2);
       case 4:
         return this.sLeftEV(distance, eventId, eventId2);
       case 6:
         return this.sRightEV(distance, eventId, eventId2);
       case 8:
         return this.sOverEV(distance, eventId, eventId2);
       default:
         break;
     }
   };
  
  
  
   /**
    * Verifica se está somente atrás do evento
    *
    * @method sBehind
    * @param distance {Number} Distância.
    * @param eventId {Number} ID do evento.
    * @return {Boolean}
    */
    Game_Interpreter.prototype.sBehind = function (distance, eventId) {
      // body...
      switch  ( ($.eventMap(eventId, this._eventId)).direction() ) {
        case 8:
          return this.sUnder(distance, eventId);
        case 6:
          return this.sLeft(distance+1, eventId);
        case 4:
          return this.sRight(distance+1, eventId);
        case 2:
          return this.sOver(distance, eventId);
        default:
          break;
      }
    };
 
 
 /**
    * Verifica se está somente atrás do evento
    *
    * @method sBehindEV
    * @param distance {Number} Distância.
    * @param eventId {Number} ID do evento.
    * @return {Boolean}
    */
    Game_Interpreter.prototype.sBehindEV = function (distance, eventId, eventId2) {
      // body...
      switch  ( ($.eventMap(eventId, this._eventId)).direction() ) {
        case 8:
          return this.sUnderEV(distance, eventId, eventId2);
        case 6:
          return this.sLeftEV(distance+1, eventId, eventId2);
        case 4:
          return this.sRightEV(distance+1, eventId, eventId2);
        case 2:
          return this.sOverEV(distance, eventId, eventId2);
        default:
          break;
      }
    };
 
 
    /**
     * Verifica se está somente à esquerda do evento.
     *
     * @method vLeft
     * @param distance {Number} Distância.
     * @param eventId {Number} ID do evento.
     * @return {Boolean}
     */
     Game_Interpreter.prototype.vLeft = function (distance, eventId) {
       // body...
       switch  ( ($.eventMap(eventId, this._eventId)).direction() ) {
         case 4:
           return this.sUnder(distance, eventId);
         case 8:
           return this.sLeft(distance+1, eventId);
         case 2:
           return this.sRight(distance+1, eventId);
         case 6:
           return this.sOver(distance, eventId);
         default:
           break;
       }
     };
 
 
 
     /**
     * Verifica se está somente à esquerda do evento.
     *
     * @method vLeftEV / FAYE INPUT: Evalúa la verdadera izquierda. Si está de frente, su verdadera izquierda será la derecha.
     * @param distance {Number} Distância.
     * @param eventId {Number} ID do evento.
     * @return {Boolean}
     */
     Game_Interpreter.prototype.vLeftEV = function (distance, eventId, eventId2) {
       // body...
       switch  ( ($.eventMap(eventId, this._eventId)).direction() ) {
         case 4:
           return this.sUnderEV(distance, eventId, eventId2);
         case 8:
           return this.sLeftEV(distance+1, eventId, eventId2);
         case 2:
           return this.sRightEV(distance+1, eventId, eventId2);
         case 6:
           return this.sOverEV(distance, eventId, eventId2);
         default:
           break;
       }
     };
 
 
 
     /**
      * Verifica se está somente à direita do evento.
      *
      * @method vRight
      * @param distance {Number} Distância.
      * @param eventId {Number} ID do evento.
      * @return {Boolean}
      */
      Game_Interpreter.prototype.vRight = function (distance, eventId) {
        // body...
        switch  ( ($.eventMap(eventId, this._eventId)).direction() ) {
          case 4:
            return this.sUnder(distance, eventId);
          case 2:
            return this.sLeft(distance+1, eventId);
          case 8:
            return this.sRight(distance+1, eventId);
          case 6:
            return this.sOver(distance, eventId);
          default:
            break;
        }
      };
  
  
  
  
       /**
      * Verifica se está somente à direita do evento.
      *
      * @method vRightEV
      * @param distance {Number} Distância.
      * @param eventId {Number} ID do evento.
      * @return {Boolean}
      */
      Game_Interpreter.prototype.vRightEV = function (distance, eventId, eventId2) {
        // body...
        switch  ( ($.eventMap(eventId, this._eventId)).direction() ) {
          case 4:
            return this.sUnderEV(distance, eventId, eventId2);
          case 2:
            return this.sLeftEV(distance+1, eventId, eventId2);
          case 8:
            return this.sRightEV(distance+1, eventId, eventId2);
          case 6:
            return this.sOverEV(distance, eventId, eventId2);
          default:
            break;
        }
      };
  
  
  
      /**
       * Verifica se está ao lado esquerdo-superior na diagonal.
       *
       * @method dUpperLeft
       * @param distance {Number} Distância.
       * @param eventId {Number} ID do evento.
       * @return {Boolean}
       */
       Game_Interpreter.prototype.dUpperLeftEV = function (distance, eventId) {
         var _event = $.eventMap(eventId, this._eventId);
         for (var i = 0; i < distance+1; i++) {
           if ( ($gamePlayer.x == (_event.x - i) ) && ($gamePlayer.y == (_event.y - i) ) )
            return true;
         }
         return false;
       };

  
       /**
       * Verifica se está ao lado esquerdo-superior na diagonal.
       *
       * @method dUpperLeftEV
       * @param distance {Number} Distância.
       * @param eventId {Number} ID do evento.
       * @return {Boolean}
       */
       Game_Interpreter.prototype.dUpperLeftEV = function (distance, eventId, eventId2) {
         var _event = $.eventMap(eventId, this._eventId);
 var _eventar = $.eventMap2(eventId2, this._eventId2);
         for (var i = 0; i < distance+1; i++) {
           if ( (_eventar.x == (_event.x - i) ) && (_eventar.y == (_event.y - i) ) )
            return true;
         }
         return false;
       };
  
  
  
       /**
        * Verifica se está ao lado direito-superior na diagonal.
        *
        * @method dUpperRight
        * @param distance {Number} Distância.
        * @param eventId {Number} ID do evento.
        * @return {Boolean}
        */
        Game_Interpreter.prototype.dUpperRight = function (distance, eventId) {
          var _event = $.eventMap(eventId, this._eventId);
          for (var i = 0; i < distance+1; i++) {
            if ( ($gamePlayer.x == (_event.x + i) ) && ($gamePlayer.y == (_event.y - i) ) )
             return true;
          }
          return false;
        };
 
 
       /**
        * Verifica se está ao lado direito-superior na diagonal.
        *
        * @method dUpperRightEV
        * @param distance {Number} Distância.
        * @param eventId {Number} ID do evento.
        * @return {Boolean}
        */
        Game_Interpreter.prototype.dUpperRightEV = function (distance, eventId, eventId2) {
          var _event = $.eventMap(eventId, this._eventId);
   var _eventar = $.eventMap2(eventId2, this._eventId2);
          for (var i = 0; i < distance+1; i++) {
            if ( (_eventar.x == (_event.x + i) ) && (_eventar.y == (_event.y - i) ) )
             return true;
          }
          return false;
        };
 
 
 
 
        /**
         * Verifica se está ao lado esquerdo-inferior na diagonal.
         *
         * @method iBelowLeft
         * @param distance {Number} Distância.
         * @param eventId {Number} ID do evento.
         * @return {Boolean}
         */
         Game_Interpreter.prototype.iBelowLeft = function (distance, eventId) {
           var _event = $.eventMap(eventId, this._eventId);
           for (var i = 0; i < distance+1; i++) {
             if ( ($gamePlayer.x == (_event.x - i) ) && ($gamePlayer.y == (_event.y + i) ) )
              return true;
           }
           return false;
         };
 
 
 
  /**
         * Verifica se está ao lado esquerdo-inferior na diagonal.
         *
         * @method iBelowLeftEV
         * @param distance {Number} Distância.
         * @param eventId {Number} ID do evento.
         * @return {Boolean}
         */
         Game_Interpreter.prototype.iBelowLeftEV = function (distance, eventId, eventId2) {
           var _event = $.eventMap(eventId, this._eventId);
   var _eventar = $.eventMap2(eventId2, this._eventId2);
           for (var i = 0; i < distance+1; i++) {
             if ( (_eventar.x == (_event.x - i) ) && (_eventar.y == (_event.y + i) ) )
              return true;
           }
           return false;
         };
 
 
 
         /**
          * Verifica se está ao lado direito-inferior na diagonal.
          *
          * @method iBelowRight
          * @param distance {Number} Distância.
          * @param eventId {Number} ID do evento.
          * @return {Boolean}
          */
          Game_Interpreter.prototype.iBelowRight = function (distance, eventId) {
            var _event = $.eventMap(eventId, this._eventId);
            for (var i = 0; i < distance+1; i++) {
              if ( ($gamePlayer.x == (_event.x + i) ) && ($gamePlayer.y == (_event.y + i) ) )
               return true;
            }
            return false;
          };
  
  
  
           /**
          * Verifica se está ao lado direito-inferior na diagonal.
          *
          * @method iBelowRightEV
          * @param distance {Number} Distância.
          * @param eventId {Number} ID do evento.
          * @return {Boolean}
          */
          Game_Interpreter.prototype.iBelowRightEV = function (distance, eventId, eventId2) {
            var _event = $.eventMap(eventId, this._eventId);
 var _eventar = $.eventMap2(eventId2, this._eventId2);
            for (var i = 0; i < distance+1; i++) {
              if ( (_eventar.x == (_event.x + i) ) && (_eventar.y == (_event.y + i) ) )
               return true;
            }
            return false;
          };
  
  
  
          /**
           * Verifica se a diagonal em todos os lados
           *
           * @method sDiagonal
           * @param distance {Number} Distância.
           * @param eventId {Number} ID do evento.
           * @return {Boolean}
           */
           Game_Interpreter.prototype.sDiagonal = function (distance, eventId) {
             return ( this.dUpperLeft(distance, eventId) || this.dUpperRight(distance, eventId) ||
                      this.iBelowLeft(distance, eventId) || this.iBelowRight(distance, eventId));
           };
  
  
  
  
    /**
           * Verifica se a diagonal em todos os lados
           *
           * @method sDiagonalEV
           * @param distance {Number} Distância.
           * @param eventId {Number} ID do evento.
           * @return {Boolean}
           */
           Game_Interpreter.prototype.sDiagonalEV = function (distance, eventId, eventId2) {
             return ( this.dUpperLeftEV(distance, eventId, eventId2) || this.dUpperRightEV(distance, eventId, eventId2) ||
                      this.iBelowLeftEV(distance, eventId, eventId2) || this.iBelowRightEV(distance, eventId, eventId2));
           };
  
  
           /**
            * Verifica a diagonal de acordo com a visão do evento.
            *
            * @method vTargetDiagonal
            * @param distance {Number} Distância.
            * @param eventId {Number} ID do evento.
            * @return {Boolean}
            */
            Game_Interpreter.prototype.vTargetDiagonal = function (distance, eventId) {
              // body...
              switch  ( ($.eventMap(eventId, this._eventId)).direction() ) {
                case 2:
                  return (this.iBelowLeft(distance, eventId) || this.iBelowRight(distance, eventId));
                case 4:
                  return (this.dUpperLeft(distance, eventId) || this.iBelowLeft(distance, eventId));
                case 6:
                  return (this.dUpperRight(distance, eventId) || this.iBelowRight(distance, eventId));
                case 8:
                  return (this.dUpperLeft(distance, eventId) || this.dUpperRight(distance, eventId));
                default:
                  break;
              }
            };
 
 
 /**
            * Verifica a diagonal de acordo com a visão do evento.
            *EV
            * @method vTargetDiagonal
            * @param distance {Number} Distância.
            * @param eventId {Number} ID do evento.
            * @return {Boolean}
            */
            Game_Interpreter.prototype.vTargetDiagonalEV = function (distance, eventId, eventId2) {
              // body...
              switch  ( ($.eventMap(eventId, this._eventId)).direction() ) {
                case 2:
                  return (this.iBelowLeftEV(distance, eventId, eventId2) || this.iBelowRightEV(distance, eventId, eventId2));
                case 4:
                  return (this.dUpperLeftEV(distance, eventId, eventId2) || this.iBelowLeftEV(distance, eventId, eventId2));
                case 6:
                  return (this.dUpperRightEV(distance, eventId, eventId2) || this.iBelowRightEV(distance, eventId, eventId2));
                case 8:
                  return (this.dUpperLeftEV(distance, eventId, eventId2) || this.dUpperRightEV(distance, eventId, eventId2));
                default:
                  break;
              }
            };
 
 
 
            /**
             * Verifica em forma de círculo.
             *
             * @method sPerimeter
             * @param distance {Number} Distância.
             * @param eventId {Number} ID do evento.
             * @return {Boolean}
             */
             Game_Interpreter.prototype.sPerimeter = function (distance, eventId) {
               var _distance = distance < 2 ? 2 : distance;
               return ( this.sDiagonal(_distance - 1, eventId) || this.sCross(_distance, eventId) );
             };
 
 
 /**
             * Verifica em forma de círculo.
             *
             * @method sPerimeterEV
             * @param distance {Number} Distância.
             * @param eventId {Number} ID do evento.
             * @return {Boolean}
             */
             Game_Interpreter.prototype.sPerimeterEV = function (distance, eventId, eventId2) {
               var _distance = distance < 2 ? 2 : distance;
               return ( this.sDiagonalEV(_distance - 1, eventId, eventId2) || this.sCrossEV(_distance, eventId, eventId2) );
             };
 
})(Kvothe.UltimateSensorEvent);
Imported["UltimateSensorEvent"] = true;
Créditos:
Kvothe/Reshi

#2 Re: | MV | Ultimate Sensor Event 1.1 el Dom Nov 20, 2016 8:17 pm

Vala

avatar
¡Geniaaaaaaal!
Yo no uso el MV, pero basta con leer la descripción para darse cuenta de la gran utilidad del plugin.
Estoy segura de que a muchas personas les servirá.
Ópalo Reputación por el aporte, Faye. Como siempre, ayudando a la comunidad.

Saludos,
Vala.



#3 Re: | MV | Ultimate Sensor Event 1.1 el Lun Nov 21, 2016 11:11 pm

Natalie

avatar
Jajaj, ¡nunca falta esta opción! Yo creo que mola mucho estos "mini juegos" de huir del guardia, ahora los usuarios del Mv también podrán disfrutar de él, ¡gracias Faye Ópalo Reputación !

#4 Re: | MV | Ultimate Sensor Event 1.1 el Mar Nov 22, 2016 4:28 am

Brrt

avatar
oooooh bastante interesante, mi proyecto the Unkrown necesita esto, no lo entiendo del todo muy bien. Pero sere buen estudiante y leere bien para entenderlo. Muchas gracias por tus esfuerzos. Ópalo Reputación

#5 Re: | MV | Ultimate Sensor Event 1.1 el Miér Nov 23, 2016 6:30 pm

Tomate

avatar
¡Qué genial, Faye! Y sin darte cuenta vas aprendiendo cada vez más programación Ópalo Contento

De por sí este "plugin" se ve bastante interesante, pero creo que tu edición para mejorarlo se merece un aplauso y un Ópalo Reputación por el esfuerzo.

Voy a tenerlo guardado por si acaso, para cuando retome con el MV.

¡Gracias! Ópalo Contento

Contenido patrocinado


Ver el tema anterior Ver el tema siguiente Volver arriba  Mensaje [Página 1 de 1.]

Permisos de este foro:
No puedes responder a temas en este foro.