# Actions in Brief¶

Think of actions as what Antescofo undertakes as a result of arriving at an instant in time. In traditional practices of interactive music, actions are message passing through qlist object in Max/Pd (or alternatively message boxes or COLL, PATTR objects in MAX). Actions in Antescofo allow more explicit organization of computer reactions over time and also with regards to themselves. See section message for a detailed description of the message passing mechanism.

Actions are divided into atomic actions performing an elementary computation or simple message passing, and compound actions. Compound actions group other actions allowing polyphony, loops and interpolated curves. An action is triggered by the event or the action that immediately precedes it.

In the new syntax, an action, either atomic or compound, starts with an optional delay, as defined hereafter. The old syntax for compound action, where the delay is after the keyword, is still recognized.

##### Action Attributes¶

Each action has some optional attributes which appear as a comma separated list:

  atomic_action @att1, @att2 := value
compound_action @att1, @att2 := value { ... }


In this example, @att1 is an attribute limited to one keyword, and @att2 is an attribute that require a parameter. The parameter is given after the optional sign :=.

Some attributes are specific to some kind of actions. There is however one attribute that can be specified for all actions: label. It is described in section Action Label. The attributes specific to a given kind of action are described in the section dedicated to this kind of action.

## Delays¶

An optional specification of a delay d can be given before any action a. This defines the amount of time between the previous event or the previous action in the score and the computation of a. At the expiration of the delay, we say that the action is fired (we use also the word triggered or launched). Thus, the following sequence

          NOTE C3 2.0
d1 action1
d2 action2
NOTE D3 1.0


specifies that, in an ideal performance that adheres strictly to the temporal constraint specified in the score, action1 will be fired d1 after the recognition of the C note, and action2 will be triggered d2 after the launching of action1.

A delay can be any expression. This expression is evaluated when the preceding event is launched. That is, expression d2 is evaluated in the logical instant where action1 is computed. If the result is not a number, an error is signaled.

##### Zero Delay¶

The absence of a delay is equivalent to a zero delay. A zero-delayed action is launched synchronously with the preceding action or with the recognition of its associated event. Synchronous actions are performed in the same logical instant and last zero time, cf. paragraph Logical Instant.

##### Absolute and Relative Delay¶

A delay can be either absolute or relative. An absolute delay is expressed in seconds or milliseconds and refers to wall clock time or physical time. The qualifier s (respectively ms) is used to denote an absolute delay:

                   a0
1 s a1
(2*$v) ms a2  Action a1 occurs one second after a0 and a2 occurs (2*$v) milliseconds after a1. If the qualifier s or ms is missing, the delay is expressed in beats and it is relative to the tempo of the enclosing group (see section local tempo).

##### Evaluation of a Delay¶

In the previous example, the computed value of a2's delay may depend of the date of the computation (for instance, the variable may be updated somewhere else in parallel). So, it is important to know when the computation of a delay occurs: it takes place when the previous action is launched, since the launching of this action is also the start of the delay. And the delay of the first action in a group is computed when the group is launched.

A second remark is that, once computed, the delay itself is not reevaluated until its expiration. However, the delay can be expressed in the relative tempo or relatively to a computed tempo and its mapping into the physical time is reevaluated as needed, that is, when the tempo changes.

##### Synchronization Strategies¶

Delays can be seen as temporal relationships between actions. There are several ways, called synchronization strategies, to implement these temporal relationships at runtime. For instance, assuming that in the first example of this section action2 actually occurs after the occurrence of NOTE D, one may count a delay of d1 + d2 - 2.0 starting from NOTE D after launching action2. This approach will be for instance more tightly coupled with the stream of musical events. Synchronization strategies are discussed in section synchronization strategies.

## Label¶

Labels are used to refer to actions. Like events, actions can be labeled with

• a simple identifier,

• a string,

• an integer.

The labels of an action are specified using the @name keyword:

          ... @name := somelabel
... @name somelabel


One action can have several labels. Unlike with event labels, the \$-identifier associated with an action label cannot be used to refer to the relative position of this action in the score1.

Compound actions have an optional identifier (section compound action). This is a simple identifier and acts as a label for the action without the burden to explicitly use the @name attribute.

## Action Execution¶

We write at the beginning of this chapter that actions are performed when arriving at an instant in time. But the specification of this date can take several forms. It can be

• the occurrence of a musical event;

• the occurrence of a logical event (see the whenever construction page  and the pattern specification at page Whenever);

• the loading of the score (cf. the @eval_when_load construct at page Eval when Load);

• the signal spanned by an @abort action (see abort handler at page Abort);

• the sampling of a curve construct (page Curve);

• the instance of an iterative construct (pages Loop and ForAll);

• or the expiration of a delay starting with the triggering of another action.

1. There is no useful notion of position of an action in the score because the same action may be fired several times (actions inside a loop body or a or associated to a whenever or a process).