Triggers

Compiles

A trigger is an invisible volume that notices things entering it. The shipped box_trigger script creates the volume; your script sits on the same entity and receives trigger_overlapped whenever something overlaps.

my_triggertransformbox_triggeryour_script← your script

box_trigger makes the volume; its size comes from the entity's scale. Every script on the entity hears about overlaps.

React to a player

event export fn trigger_overlapped(other, unused) {
  if !other {
    return
  }
  let player: Component = $entity.get_hierarchy_singleton("catch_player.vscript", $component.get_entity(other))
  if !player {
    return
  }
  $debug.print_line("a player arrived", null, false)
}

other is the component that overlapped, usually a collider somewhere inside the player, which is why we search its hierarchy for catch_player rather than checking other itself.

React to a ball

Balls have a ball_transform. A held ball travels inside its holder, so you usually want only loose ones:

fn loose_ball(touched: Entity) -> Component {
  let ball: Component = $entity.get_hierarchy_singleton("ball_transform.vscript", touched)
  if !ball {
    return null
  }
  let throwable: Component = $support.entity_get_component($component.get_entity(ball), "throwable_base.vscript")
  if throwable && throwable.holder {
    return null
  }
  return ball
}

Don’t fire every frame

Something standing in a trigger overlaps it frame after frame. Add a cooldown:

let cooldown_seconds: float = 1.0
let mut last_fired_ms: int = -1000000

event export fn trigger_overlapped(other, unused) {
  let now: int = $time.get_gameplay_time_ms()
  if now - last_fired_ms < $time.seconds_to_ms(cooldown_seconds) {
    return
  }
  last_fired_ms = now
  $debug.print_line("fired", null, false)
}

Fire only once, ever

let mut used: bool = false

event export fn trigger_overlapped(other, unused) {
  if used {
    return
  }
  used = true
  $debug.print_line("first visitor!", null, false)
}

Decide on the server

The overlap happens on every machine. If the trigger changes something everyone must agree on, like a score or a door, let only the server do it, and replicate the result (Replication):

let mut visits: int = 0

event export fn trigger_overlapped(other, unused) {
  if !$net.is_server() {
    return
  }
  visits = visits + 1
}