1. 1 : import { TriggerRegion } from './TriggerRegion.js';
  2. 2 : import { RectangularTriggerRegion } from './regions/RectangularTriggerRegion.js';
  3. 3 : import { SphericalTriggerRegion } from './regions/SphericalTriggerRegion.js';
  4. 4 : import { GameEntity } from '../core/GameEntity.js';
  5. 5 : import { Logger } from '../core/Logger.js';
  6. 6 : 
  7. 7 : /**
  8. 8 : * Base class for representing triggers. A trigger generates an action if a game entity
  9. 9 : * touches its trigger region, a predefine area in 3D space.
  10. 10 : *
  11. 11 : * @author {@link https://github.com/Mugen87|Mugen87}
  12. 12 : * @augments GameEntity
  13. 13 : */
  14. 14 : class Trigger extends GameEntity {
  15. 15 : 
  16. 16 : 	/**
  17. 17 : 	* Constructs a new trigger with the given values.
  18. 18 : 	*
  19. 19 : 	* @param {TriggerRegion} region - The region of the trigger.
  20. 20 : 	*/
  21. 21 : 	constructor( region = new TriggerRegion() ) {
  22. 22 : 
  23. 23 : 		super();
  24. 24 : 
  25. 25 : 		/**
  26. 26 : 		* The region of the trigger.
  27. 27 : 		* @type {TriggerRegion}
  28. 28 : 		*/
  29. 29 : 		this.region = region;
  30. 30 : 
  31. 31 : 		//
  32. 32 : 
  33. 33 : 		this.canActivateTrigger = false; // triggers can't activate other triggers by default
  34. 34 : 
  35. 35 : 		this._typesMap = new Map(); // used for deserialization of custom trigger regions
  36. 36 : 
  37. 37 : 	}
  38. 38 : 
  39. 39 : 	/**
  40. 40 : 	* This method is called per simulation step for all game entities. If the game
  41. 41 : 	* entity touches the region of the trigger, the respective action is executed.
  42. 42 : 	*
  43. 43 : 	* @param {GameEntity} entity - The entity to test
  44. 44 : 	* @return {Trigger} A reference to this trigger.
  45. 45 : 	*/
  46. 46 : 	check( entity ) {
  47. 47 : 
  48. 48 : 		if ( this.region.touching( entity ) === true ) {
  49. 49 : 
  50. 50 : 			this.execute( entity );
  51. 51 : 
  52. 52 : 		}
  53. 53 : 
  54. 54 : 		return this;
  55. 55 : 
  56. 56 : 	}
  57. 57 : 
  58. 58 : 	/**
  59. 59 : 	* This method is called when the trigger should execute its action.
  60. 60 : 	* Must be implemented by all concrete triggers.
  61. 61 : 	*
  62. 62 : 	* @param {GameEntity} entity - The entity that touched the trigger region.
  63. 63 : 	* @return {Trigger} A reference to this trigger.
  64. 64 : 	*/
  65. 65 : 	execute( /* entity */ ) {}
  66. 66 : 
  67. 67 : 	/**
  68. 68 : 	* Updates the region of this trigger. Called by the {@link EntityManager} per
  69. 69 : 	* simulation step.
  70. 70 : 	*
  71. 71 : 	* @return {Trigger} A reference to this trigger.
  72. 72 : 	*/
  73. 73 : 	updateRegion() {
  74. 74 : 
  75. 75 : 		this.region.update( this );
  76. 76 : 
  77. 77 : 		return this;
  78. 78 : 
  79. 79 : 	}
  80. 80 : 
  81. 81 : 	/**
  82. 82 : 	* Transforms this instance into a JSON object.
  83. 83 : 	*
  84. 84 : 	* @return {Object} The JSON object.
  85. 85 : 	*/
  86. 86 : 	toJSON() {
  87. 87 : 
  88. 88 : 		const json = super.toJSON();
  89. 89 : 
  90. 90 : 		json.region = this.region.toJSON();
  91. 91 : 
  92. 92 : 		return json;
  93. 93 : 
  94. 94 : 	}
  95. 95 : 
  96. 96 : 	/**
  97. 97 : 	* Restores this instance from the given JSON object.
  98. 98 : 	*
  99. 99 : 	* @param {Object} json - The JSON object.
  100. 100 : 	* @return {Trigger} A reference to this trigger.
  101. 101 : 	*/
  102. 102 : 	fromJSON( json ) {
  103. 103 : 
  104. 104 : 		super.fromJSON( json );
  105. 105 : 
  106. 106 : 		const regionJSON = json.region;
  107. 107 : 		let type = regionJSON.type;
  108. 108 : 
  109. 109 : 		switch ( type ) {
  110. 110 : 
  111. 111 : 			case 'TriggerRegion':
  112. 112 : 				this.region = new TriggerRegion().fromJSON( regionJSON );
  113. 113 : 				break;
  114. 114 : 
  115. 115 : 			case 'RectangularTriggerRegion':
  116. 116 : 				this.region = new RectangularTriggerRegion().fromJSON( regionJSON );
  117. 117 : 				break;
  118. 118 : 
  119. 119 : 			case 'SphericalTriggerRegion':
  120. 120 : 				this.region = new SphericalTriggerRegion().fromJSON( regionJSON );
  121. 121 : 				break;
  122. 122 : 
  123. 123 : 			default:
  124. 124 : 				// handle custom type
  125. 125 : 
  126. 126 : 				const ctor = this._typesMap.get( type );
  127. 127 : 
  128. 128 : 				if ( ctor !== undefined ) {
  129. 129 : 
  130. 130 : 					this.region = new ctor().fromJSON( regionJSON );
  131. 131 : 
  132. 132 : 				} else {
  133. 133 : 
  134. 134 : 					Logger.warn( 'YUKA.Trigger: Unsupported trigger region type:', regionJSON.type );
  135. 135 : 
  136. 136 : 				}
  137. 137 : 
  138. 138 : 		}
  139. 139 : 
  140. 140 : 		return this;
  141. 141 : 
  142. 142 : 	}
  143. 143 : 
  144. 144 : 	/**
  145. 145 : 	 * Registers a custom type for deserialization. When calling {@link Trigger#fromJSON}
  146. 146 : 	 * the trigger is able to pick the correct constructor in order to create custom
  147. 147 : 	 * trigger regions.
  148. 148 : 	 *
  149. 149 : 	 * @param {String} type - The name of the trigger region.
  150. 150 : 	 * @param {Function} constructor - The constructor function.
  151. 151 : 	 * @return {Trigger} A reference to this trigger.
  152. 152 : 	 */
  153. 153 : 	registerType( type, constructor ) {
  154. 154 : 
  155. 155 : 		this._typesMap.set( type, constructor );
  156. 156 : 
  157. 157 : 		return this;
  158. 158 : 
  159. 159 : 	}
  160. 160 : 
  161. 161 : }
  162. 162 : 
  163. 163 : export { Trigger };