rename Trigger to Sensor

src/physics/Hitbox.hpp

@@ -10,32 +10,32 @@
 #include <functional>
 #include <glm/glm.hpp>
 
-enum class TriggerType {
+enum class SensorType {
     AABB,
     RADIUS,
 };
 
-union TriggerParams {
+union SensorParams {
     AABB aabb;
     glm::vec4 radial; // x,y,z calculated entity coords + w - radius
 
-    constexpr TriggerParams() : aabb() {
+    constexpr SensorParams() : aabb() {
     }
 };
 
-using triggercallback = std::function<void(entityid_t, size_t, entityid_t)>;
+using sensorcallback = std::function<void(entityid_t, size_t, entityid_t)>;
 
-struct Trigger {
+struct Sensor {
     bool enabled = true;
-    TriggerType type;
+    SensorType type;
     size_t index;
     entityid_t entity;
-    TriggerParams params;
-    TriggerParams calculated;
+    SensorParams params;
+    SensorParams calculated;
     std::set<entityid_t> prevEntered;
     std::set<entityid_t> nextEntered;
-    triggercallback enterCallback;
-    triggercallback exitCallback;
+    sensorcallback enterCallback;
+    sensorcallback exitCallback;
 };
 
 enum class BodyType {

src/physics/PhysicsSolver.cpp

@@ -87,28 +87,28 @@ void PhysicsSolver::step(
     AABB aabb;
     aabb.a = hitbox->position - hitbox->halfsize;
     aabb.b = hitbox->position + hitbox->halfsize;
-    for (size_t i = 0; i < triggers.size(); i++) {
-        auto& trigger = *triggers[i];
-        if (trigger.entity == entity) {
+    for (size_t i = 0; i < sensors.size(); i++) {
+        auto& sensor = *sensors[i];
+        if (sensor.entity == entity) {
             continue;
         }
 
         bool triggered = false;
-        switch (trigger.type) {
-            case TriggerType::AABB:
-                triggered = aabb.intersect(trigger.calculated.aabb);
+        switch (sensor.type) {
+            case SensorType::AABB:
+                triggered = aabb.intersect(sensor.calculated.aabb);
                 break;
-            case TriggerType::RADIUS:
+            case SensorType::RADIUS:
                 triggered = glm::distance2(
-                    hitbox->position, glm::vec3(trigger.calculated.radial))
-                     < trigger.calculated.radial.w;
+                    hitbox->position, glm::vec3(sensor.calculated.radial))
+                     < sensor.calculated.radial.w;
                 break;
         }
         if (triggered) {
-            if (trigger.prevEntered.find(entity) == trigger.prevEntered.end()) {
-                trigger.enterCallback(trigger.entity, trigger.index, entity);
+            if (sensor.prevEntered.find(entity) == sensor.prevEntered.end()) {
+                sensor.enterCallback(sensor.entity, sensor.index, entity);
             }
-            trigger.nextEntered.insert(entity);
+            sensor.nextEntered.insert(entity);
         }
     }
 }

src/physics/PhysicsSolver.hpp

@@ -11,11 +11,11 @@
 
 class Block;
 class Chunks;
-struct Trigger;
+struct Sensor;
 
 class PhysicsSolver {
     glm::vec3 gravity;
-    std::vector<Trigger*> triggers;
+    std::vector<Sensor*> sensors;
 public:
     PhysicsSolver(glm::vec3 gravity);
     void step(
@@ -36,8 +36,8 @@ public:
     bool isBlockInside(int x, int y, int z, Hitbox* hitbox);
     bool isBlockInside(int x, int y, int z, Block* def, blockstate state, Hitbox* hitbox);
 
-    void setTriggers(std::vector<Trigger*> triggers) {
-        this->triggers = std::move(triggers);
+    void setSensors(std::vector<Sensor*> sensors) {
+        this->sensors = std::move(sensors);
     }
 };