Press counter

Compiles

A pad that counts how many times players have stepped on it. The count is the kind of thing everyone must agree on, so the server keeps it and replicates it to every player’s game. It’s the smallest complete example of the pattern behind scores, unlocks and match state.

Put it on an entity with a box_trigger, like the teleport pad.

Server

Each player's game

trigger_overlapped: is_server, count it

trigger_overlapped: not the server, ignore

presses = presses + 1

presses (0–9999)

presses updated

field_replicated: print the new count

1
// press_counter.vscript: counts how many times players have stepped on a
2
// pad, and tells every player's game when the count changes.
3
//
4
// The server owns the count. Players' games never change it; they are sent
5
// each new value and react to it.
6
//
7
// Sits on the same entity as a box_trigger.
8

9
// Seconds between counted presses, so standing on the pad counts once.
10
let cooldown_seconds: float = 1.0;
11

12
// The count. Replicated: the server's value is sent to every player.
13
let mut presses: int = 0;
14

15
// Server only: when the last press was counted.
16
let mut last_press_ms: int = -100000;
17

18
event export fn type_created() {
19
  // Components of this script replicate.
20
  $net.set_replicated(true, false);
21

22
  // `presses` replicates as a whole number from 0 to 9999, and players'
23
  // games get a field_replicated event each time a new value arrives.
24
  $net.set_field_replicated("presses", true, false, false, false, false, "", false, 0, 9999, 1, true);
25

26
  // `last_press_ms` is the server's own bookkeeping; keep it off the wire.
27
  $net.set_field_replicated("last_press_ms", false, false, false, false, false, "", false, 0, 0, 0, false);
28
}
29

30
event export fn trigger_overlapped(other, unused) {
31
  // Every machine sees the overlap; only the server counts it.
32
  if !$net.is_server() || !other {
33
    return;
34
  }
35
  let player: Component = $entity.get_hierarchy_singleton("catch_player.vscript", $component.get_entity(other));
36
  if !player {
37
    return;
38
  }
39
  let now: int = $time.get_gameplay_time_ms();
40
  if now - last_press_ms < $time.seconds_to_ms(cooldown_seconds) {
41
    return;
42
  }
43
  last_press_ms = now;
44
  presses = presses + 1;
45
  $debug.print_line("[press_counter] server counted press {}", [presses], false);
46
}
47

48
// On each player's game: a new count arrived from the server.
49
event export fn field_replicated(field, previous) {
50
  if field == "presses" {
51
    $debug.print_line("[press_counter] count went from {} to {}", [previous, presses], false);
52
  }
53
}

One setting, two pieces of statelines 9-16
presses is the count everyone sees. last_press_ms is the server’s own note of when it last counted.
Set up replicationlines 18-28
Replicate this script’s components; send presses as a whole number from 0 to 9999 and fire field_replicated when it arrives; keep last_press_ms off the network entirely.
Count, on the server onlylines 30-45
Every machine sees the overlap. Only the server passes the first guard. Then it checks that it’s a player and that the cooldown has passed, and counts.
React on each player's gamelines 47-52
field_replicated runs when a new value arrives, with the field’s name and its previous value. The field already holds the new one.

Try changing it

Show the count to players instead of printing it: in field_replicated, send an event to a UI component.
Count per team or per player: keep a list of counts, and replicate the numbers you need to show.
Reset the count at the start of each round: on the server, set presses = 0, and every client is told.