Gorilla Script Reference

Examples

Simple examples

Simple script 1
This script simply displays the text Hello World! on the Status line (below the Script text box in the Instrument Editor.

Any statements between on init and end on are performed immediately when the script is loaded.

on init
  print("Hello World!")
end on

Simple script 2
In this script we define a variable x and set it to the value 1. We then append the variable to the text value is and display the combined result as value is 1 on the Status line:

on init
  var x = 1
  print("value is " & x)
end on

Simple script 3
In this script we define a function that should display the value of the variable x after a mathematical calculation.

Further down in the script we call the print function to display the value of x on the Status line:

function print_x
  print(x)
end function

on init var x
  x = 3 * -7 + 100 / 2
  print_x 'should print 29
end on

Simple script 4
In this script we define a variable x and set it to the value 1.

We then demonstrate using the conditions if, else and while, and the function inc() to increase the value of x for as long as the while condition is true.

The resulting value x is then displayed on the Status line:

on init
  var x = 1

  if x > 2
    return
  else
    x = -4 * x + 3
  end if

  while x < 10
    inc(x)
  end while

  print(x) 'should print 10
end on

Simple script 5
In the previous examples we wanted something to happen when the script started (between on init and end on).

In this example we want something to happen when a MIDI controller value changes, so we put the statements between on controller and end on.

A section of the script starting with on ... and ending with end on is known as a callback. In this script we convert the Mod Wheel data to Sustain Pedal data:

on controller
  if EVENT_CC = 1 'convert mod wheel to sustain pedal
    set_controller(64, CC[1])
    ignore_controller() 'do not change the mod wheel too
  end if
end on

Using the Mod Wheel to select which group will play

Mod Wheel values 0 to 127 are divided by 32 to give values in the range 0 to 3 (you will need an instrument with multiple groups to hear the effect of this script):

on note
  group_off(EVENT_ID, ALL_GROUPS)
  group_on(EVENT_ID, CC[1] / 32)
  print("Playing group " & CC[1] / 32)
end on

Adding a diatonic interval to all notes

on init
  var interval[12] = (4,4,3,4,3,4,3,4,3,3,4,3)
end on

on note
  new_note(EVENT_KEY + interval[EVENT_KEY mod 12], EVENT_VEL, 0, -1)
end on

Applying changes only to the last played note

on init
  var lastNote = -1 'no event
end on

on note
  lastNote = EVENT_ID
end on

on release
  lastNote = 0
end on

on controller
  if EVENT_CC = 1 and lastNote
    set_tune(lastNote, 1575 * CC[1], 0)
  end if
end on

Applying random pitch steps to the last played note

Each new note first sets the value of lastCallback to the unique ID for that particular callback. Then, until another note arrives and changes the value of lastCallback, the tuning of the note event is adjusted to a random value for every eighth-note (480 ppq).

Why is CALLBACK_ID used instead of EVENT_ID? So this example could be expanded to use the end_delay() function to stop a delay earlier than its scheduled time.

on init
  var lastCallback
end on

on note
  'changed by each new note
  lastCallback = CALLBACK_ID

  'random tuning every 8th note
  while lastCallback = CALLBACK_ID
    delay_ppq(480)
    set_tune(EVENT_ID, 100000 * random(-12, 12), 0)
  end while
 
  'back to original tuning
  set_tune(EVENT_ID, 0, 0)
end on

Last note on each key gets release trigger

The following script keeps track of the last note played on each key and only enables the release trigger group for that note:

on init
  var lastKeyEvent[128]
end on

on note
  lastKeyEvent[EVENT_KEY] = EVENT_ID
end on

on release
  if lastKeyEvent[EVENT_KEY] != EVENT_ID 'if not last note on key
    group_off(EVENT_ID, MyReleaseNoiseGroup) 'switch off group
  end if
end on

Play samples to end, ignoring note release

on init
  var lastEventOnKey[128] = -1  '-1 is never an EVENT_ID
end on

on note
  release_note(lastEventOnKey[EVENT_KEY]) 'release the previous note on this key
end on

on release
  ignore_event(EVENT_ID) 'don't release this note yet
  lastEventOnKey[EVENT_KEY] = EVENT_ID 'but store it's ID to release later
end on

on note
  ignore_event(EVENT_ID)
  new_note(EVENT_KEY, EVENT_VEL, 0, -2) '-2 specifies a one-shot trigger
end on

Each note plays a sequence of notes

An array is used to hold an event ID for each key, which is needed to keep track of the notes that have been triggered and will later need releasing.

on init
  'current note event for each key
  var id[128]
end on

This example could be modified to play a specific sequence rather than just repeating the initial note:

on note
  'not playing this event, just using it to know how long the key is held
  ignore_event(EVENT_ID)
  while EVENT_HELD
    id[EVENT_KEY] = new_note(EVENT_KEY, EVENT_VEL, 0, 0)
    delay_ppq(960)
    release_note(id[EVENT_KEY])
  end while
end on

Modifying note events

The current property values are applied to each note as it arrives, and for Vol, Pan and Tune, a callback is specified so if the property changes while a note is playing the difference from the old value to the new value is added as a relative offset.

on init
  prop_linear Key(-12, 12, 1)
  prop_linear Vel(-100, 100, 1)
  prop_linear Vol(-20, 20, 1)
  prop_linear Pan(-1000, 1000, 1)
  prop_linear Tune(-1200, 1200, 1)
  var oldVol
  var oldPan
  var oldTune
end on

on note
  set_key(EVENT_ID, EVENT_KEY + Key)
  set_vel(EVENT_ID, EVENT_VEL + Vel)
  set_vol(EVENT_ID, 1000 * Vol, 0)
  set_pan(EVENT_ID, Pan, 0)
  set_tune(EVENT_ID, 10 * Tune, 0)
end on

on Vol
  set_vol(ALL_EVENTS, 1000 * (Vol - oldVol), 1)
  oldVol = Vol
end on

on Pan
  set_pan(ALL_EVENTS, Pan - oldPan, 1)
  oldPan = Pan
end on

on Tune
  set_tune(ALL_EVENTS, 1000 * (Tune - oldTune), 1)
  oldTune = Tune
end on

Using keyswitches to select mappings

'Scripted keyswitches example - switches the mapping played by the first group

on init
  const FirstKeyswitch = 48
  const LastKeyswitch = 52
  set_key_display(FirstKeyswitch, LastKeyswitch, KEY_COLOR_CYAN + KEY_IS_CONTROL)
  'also use set_key_name() if targeting NKS or Studio One  

  var currentKeyswitch = FirstKeyswitch
  set_key_selected(currentKeyswitch, 1)
end on

on note
  if EVENT_KEY >= FirstKeyswitch and EVENT_KEY <= LastKeyswitch
    if currentKeyswitch != EVENT_KEY
      'highlight current keyswitch  
      set_key_selected(currentKeyswitch, 0)
      currentKeyswitch = EVENT_KEY
      set_key_selected(currentKeyswitch, 1)

      'select mapping  
      set_module_param(M_GROUP+0, 0, 0, 16, currentKeyswitch - FirstKeyswitch + 1) 'Group Alternate Mapping

      'don't play a note!  
      ignore_event(EVENT_ID)
    end if
    return
  end if

end on

Sliced loop playback

The following example lists the slice positions and lengths for a zone to the debug window of the editor. See the Sliced Loop scripting examples in the SDK for actual playback.

on init
  var zone = -1000000 + 1 'a zone ID (mapping 1, zone 1 in this case) or a prop_waveform  

  var slice
  var slicePos
  var sliceLen = 1
  while sliceLen 'zero if no more slices
    slicePos = zone_slice_start(zone, slice)
    sliceLen = zone_slice_length(zone, slice)
    print("Slice " & slice & ": " & sliceLen & "us @ " & slicePos)
    inc(slice) 
  end while
end on

Equal power effect mix control

on init
  prop_linear Reverb_Mix(0, 1000, 10)
  set_prop_param(Reverb_Mix, PROP_UNITS, "%")
  var wet
  var dry
end on

function WetDryEqualPower 'convert wet (0 to 1000) to effect wet & dry levels
  dry = ((321000 + 679 * wet) * wet) / 1000000
  dry = 1000000 - dry * dry
  wet = 1000 - wet
  wet = ((321000 + 679 * wet) * wet) / 1000000
  wet = 1000000 - wet * wet
end function

on Reverb_Mix 'assumes a Convolution effect in slot 1 of bus 1
  wet = Reverb_Mix
  WetDryEqualPower
  set_module_param(M_BUS+1, M_EFFECT+1, 0, 7, dry);
  set_module_param(M_BUS+1, M_EFFECT+1, 0, 8, wet);
end on

Or for a DJ-style crossfade where both signals are at full volume in the middle:

function DJCrossfade 'convert wet (0 to 1000) to wet & dry levels
  wet = wet - 500
  if wet < 0
    dry = 1000000
    wet = 1000000 - 4 * wet * wet
  else
    dry = 1000000 - 4 * wet * wet
    wet = 1000000
  end if
end function

Calculate exponential values

function pow2
  'converts x to 1000 * 2 ^ (x / 1000)
  'so the returned value doubles each time x increases by 1000
  temp = x mod 1000
  x = (1000 + temp + ((temp - 1000) * temp) / 2980) << (x / 1000)
end function

on init
  var x     'declare the variables used by pow2 function
  var temp  '
end on

And a slightly more efficient version using a scaling factor of 1000 instead of 1024:

function pow2
  'converts x to 1024 * 2 ^ (x / 1024)
  'so the returned value doubles each time x increases by 1024
  temp = x .and. 1023
  x = (1024 + temp + ((temp - 1024) * temp) / 3012) << (x >> 10)
end function

Here is an approximation for converting a linearly increasing value to a logarithmically increasing value:

function log2
  'converts x to 1024 * log2(x / 1024)
  'so the value increases by 1024 each time x doubles
  temp = 0
  if x < 1024
    if x < 1
      return -10240 'too small
    end if
    while x < 1024
      x = x << 1
     dec(temp)
    end while
  else
    while x >= 2048
      x = x >> 1
      inc(temp)
    end while
  end if
  x = (temp << 10) + 3496 - 8642112 / (x + 1448)
end function

on init
  print ("Hello World")
end on

var x 'create a variable called x, initial value is 0
var y = 1 'create a variable called y, initial value is 1
var z = 0xFF 'create a variable called z, initial value is 255 (FF in hexadecimal)
var a[3] 'create an array that holds 3 values called a[0], a[1], a[2]
var b[4] = (10, 20, 30, 40) 'create an array and set initial values
var c["My Data"] 'create an array that reads and writes to the data in the "My Data" Data File module
var myString$ 'create a variable for storing a text string
var myString = "Hello" 'create a variable for storing text with an intial text string
var myString$[10] 'create an array for storing multiple text strings
var myString[2] = ( "one", "two" ) 'create a variable for storing text with initial text strings

const MAX_VEL = 127
var velCurve[MAX_VEL + 1]
var i = 0
while i <= MAX_VEL
  velCurve[i] = i * i
  inc(i)
end while

print("Hello")
print(3)
print(x) 'prints the current value of the variable x

on init
  var x = 3
  print("Value of x is " & x)
end on

on note
  print("Key " & EVENT_KEY & ", velocity " & EVENT_VEL)
end on

function PrintNoteInfo
  print("Key " & EVENT_KEY & " held = " & EVENT_HELD)
end function

on note
  PrintNoteInfo
end on

on release
  PrintNoteInfo
end on

function MyFunction
  if EVENT_KEY > 72
    return
  end if
  print("Key is " & EVENT_KEY) 'only gets here for keys 60 to 72
end function

on note
  if EVENT_KEY < 60
    return
  end if
  MyFunction
end on

var x 'this is a comment

var x {this is a comment} = 1

var x = 1; var y = 2 'not a good example – only use ; if it makes the code easier to read!

var a[20] = ( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ...
              11, 12, 13, 14, 15, 16, 17, 18, 19, 20 )

x = 10    'set x to 10
x = y     'set x to the value of variable y
x = a[0]  'set x to the first value in array a
a[1] = x  'set the second value in array a to the value of variable x

x = x + 10

x = x - 10
x = -x

x = x * 10

x = 5 / 2 'result is rounded down to 2

x = x << 2 'shifting left by 2 is equivalent to multiplying by 4

x = x >> 2 'shifting right by 2 is equivalent to dividing by 4

x = 10 mod 8 '10 divided by 8 is 1 with remainder 2, so x is 2

x = x .and. 1  'only the lowest bit of x is kept

x = x .or. 1  'the lowest bit of x is set to 1

x = .not. x

x = abs(-10) 'sets x to 10

if in_range(x, 10, 20)
  print("x is in between 10 and 20")
end if

x = 10
inc(x) 'x is now 11

x = 10
dec(x) 'x is now 9

x = random(3, 5) 'x has an equal chance of being 3, 4 or 5

'convert frequency 20-25000 Hz to filter cutoff parameter 0-1000000
x = real_to_int(int_to_real(140235) * log(int_to_real(x)) - int_to_real(420106))

if x 'if x is any value except zero
  x = 1 'set x to 1
end if

if x = 1 and abs(y) >= 10
  print "success"
else
  print "failure"
end if

if x < 3 
  print "too small"
else if x > 6
  print "too big"
else
  print "just right"
end if

select x
  case 1
    print "x is one"
  case 10
    print "x is ten"
  case 0 to 100
    print "x is anywhere between 0 and 100"
end select

while(x < 10)
  inc(x) 'keep doing this while x is less than 10
end while

USE_CODE_IF(DEBUG)
  print("print some debugging text")
END_USE_CODE

if x = 1
  print("success")
end if

if x != 1
  print("success")
end if

if x < 1
  print("success")  
end if

if x > 1
  print("success")
end if

if x <= 1
  print("success")
end if

if x >= 1
  print("success")
end if

if x = 1 and y < 10
  print("success")
end if

if x = 1 or y < 10
  print("success")
end if

if x > 3 and not y
  print("success")  'only if x is greater than 3 and y is 0
end if

prop_array Velocity_Curve[128](1, 127, 1) 'array of 128 values with range 1 to 127
prop_array Pitch_Sequence[16](-1200, 1200, 100) '16 values with range -12.00 and +12.00

prop_boolean My_Switch
prop_boolean Retrigger = 1

prop_decibels Volume(1000000, 12) 'when value is 1000000 display is "+12.0 dB"

prop_exp Cutoff(1000000, 20000, 25000000) = 549000 'cutoff from 20 Hz to 25 kHz, default 1 kHz
prop_exp Rate(1000000, 10, 100000) = 500000 'rate from 0.01 to 100 Hz, defaulting to 1 Hz
prop_exp Decay(1000000, -10, 16000) 'decay time from 0.0 to 16.0 sec, with 10 ms at 1%

prop_linear Mix(0, 100, 1) = 50 'display range 0 to 100
prop_linear Mix(0, 1000, 10) = 500 'display range 0.0 to 100.0
prop_linear Tune(-1200, 1200, 100) 'display range -12.00 to 12.00

'level meter at output of first effect bus
prop_meter Level; attach_meter(Level, M_BUS+1, 0)

'stereo level meter at output of third effect bus
prop_meter Level[2]; attach_meter(Level, M_BUS+3, 0)

'level or gain reduction meter (as applicable) for first effect in first effect bus
prop_meter GR; attach_meter(GR, M_BUS+1, M_EFFECT+1)

'playback position meter for first group
prop_meter Pos; attach_meter(Pos, M_GROUP+0, 0)

prop_squared Delay(0, 1000000, 0, 25) 'delay from 0.0 to 25.0 ms
prop_squared Ratio(0, 1000000, 1, 20) 'ratio from 1.0 to 20.0
prop_squared Bipolar(-1000, 1000, -100, 100) '-100 to 100 with more resolution in the middle

prop_stepped Speed = 1
add_step(Speed, "Slow")
add_step(Speed, "Normal")
add_step(Speed, "Fast")

set_prop_param(Speed, CONTROL_PAR_MAX_VALUE, 100) 'set total number of steps without providing a name for each

prop_text Name 'editable text
prop_text Status_Display; set_prop_param(StatusDisplay, PROP_SET_BY, SET_BY_SCRIPT) 'read only

prop_waveform Wave_Display
set_waveform(Wave_Display, -1, 60, 100) 'show waveform at key 60 vel 100 in the first mapping

'assign CC7 to this property
set_prop_param(Volume, PROP_MIDI_CC, 7)

'this is a display, not user editable
set_prop_param(My_Display, PROP_SET_BY, SET_BY_SCRIPT)

'do not change when loading patches
set_prop_param(Latch, PROP_SET_BY, SET_BY_HOST + SET_BY_SONG + SET_BY_REMOTE_AUTO)

'not available for automation
const NOT_AUTOMATED = SET_BY_HOST + SET_BY_SONG + SET_BY_PATCH
set_prop_param(Mode, PROP_SET_BY, NOT_AUTOMATED)

set_prop_param(Reso, PROP_NAME, "Resonance")
set_prop_param(Reso, PROP_UNITS, "%")
set_prop_param(Reso, PROP_GROUP, "Filter")

on init
  prop_boolean Mute
end on

on mute
  print("Mute value changed to " & Mute)
end on

'set parameter 2 in instrument
set_module_param(M_INST, 0, 0, 2, x)

'set parameter 2 of group 0 (groups are counted from 0)
set_module_param(M_GROUP+0, 0, 0, 2, x)

'set parameter 2 of trigger condition 1 of group 0
set_module_param(M_GROUP+0, M_COND+1, 0, 2, x)

'set parameter 2 of mod source 1 of group 0
set_module_param(M_GROUP+0, M_MOD_SRC+1, 0, 2, x)

'set parameter 2 of mod routing 3 in mod source 1 of group 0
set_module_param(M_GROUP+0, M_MOD_SRC+1, M_MOD+3, 2, x)

'set parameter 2 of filter/effect 1 of group 0
set_module_param(M_GROUP+0, M_FILTER+1, 0, 2, x)

'set parameter 2 of mod routing 3 in filter/effect 1 of group 0
set_module_param(M_GROUP+0, M_FILTER+1, M_MOD+3, 2, x)

'set parameter 2 of mod routing 1 in group 0
set_module_param(M_GROUP+0, 0, M_MOD+1, 2, x)

'set parameter 2 of zone 3 in mapping 1
set_module_param(M_MAPPING+1, M_ZONE+3, 0, 2, x)

'set parameter 2 of bus 1
set_module_param(M_BUS+1, 0, 0, 2, x)

'set parameter 2 of effect 3 in bus 1
set_module_param(M_BUS+1, M_EFFECT+3, 0, 2, x)

'set bypass parameter of first script
set_module_param(M_SCRIPT+1, 0, 0, 1, x)

'fill the curve parameter of mod routing 1 in group 0 from myArray[1000] onwards
set_module_param(M_GROUP+0, 0, M_MOD+1, 9, myArray[1000])

on init
  var orders[18] = ( 1,2,3, 1,3,2, 2,1,3, 2,3,1, 3,1,2, 3,2,1 )
  prop_stepped Order
   add_step(Order, "123")
   add_step(Order, "132")
   add_step(Order, "213")
   add_step(Order, "231")
   add_step(Order, "312")
   add_step(Order, "321")
end on

on Order
  'optionally bypass or mute effects here, wait a short time and unmute them afterwards...
  ' orderCallback = CALLBACK_ID
  ' delay(100000) 'wait for bypass to fade in
  ' if orderCallback != CALLBACK_ID 'order changed again while we were in the delay?
  '   return
  ' end if

  set_effect_order(1, orders[3 * Order]) 'first bus: choose from array of possible orders
end on

'set first routing in first group to no destination
set_mod_dest(0, 1, M_GROUP, 0, 0)

'set first routing in first group to third mod destination (Tune) of group
set_mod_dest(0, 1, M_GROUP, 3, 0)

'set 1st routing in 1st group to 1st mod destination (Volume) of group, in amp mod mode 
set_mod_dest(0, 1, M_GROUP, 1, 1)

'set 1st routing in 1st group to the 1st mod destination (Intensity) of 1st mod source
set_mod_dest(0, 1, M_MOD_SRC+1, 1, 0)

'set 1st routing in 1st group to 2nd mod destination (e.g. Resonance) in 1st filter/effect
set_mod_dest(0, 1, M_FILTER+1, 2, 0) 

on init
  var prevEvent
end on

on note
   delay(1) 'wait for this event's voice(s) to start playing
   set_mod_sources(EVENT_ID, prevEvent, 9, 1) 'copy mod sources 1 and 4 from previous event
   prevEvent = EVENT_ID

   while EVENT_HELD
     delay_ppq(960) 'then every quarternote
     set_mod_sources(EVENT_ID, 0, 255, 1) 'retrigger mod sources 1-8
  end while
end on

on controller
  print("MIDI CC " & EVENT_CC & " = " & CC[EVENT_CC])
end on

on poly_at
  print("Poly pressure key " & POLY_AT_KEY & " = " & POLY_AT[POLY_AT_KEY])
end on

on program_change
  print("Program change " & MIDI_PROGRAM)
end on

on controller
  if EVENT_CC = 1 'modwheel
    ignore_controller()
  end if
end on

on controller
  if EVENT_CC = 1 'modwheel
    set_controller(64, CC[1]) 'convert to sustain pedal
    ignore_controller()
  end if
end on

set_controller(EVENT_CHAN, 99, 1000000, 1000000) 'set CC99 to high resolution value 127.0
set_controller(EVENT_CHAN, 99, 12700, 12700) 'also sets CC99 to high resolution value 127.0
set_controller(EVENT_CHAN, 99,  500000, 1000000) 'set CC99 to high resolution value 63.5
set_controller(EVENT_CHAN, 99, -500000, 1000000) 'set CC99 to high resolution value -63.5
set_controller(EVENT_CHAN, 99, 2000000, 1000000) 'set CC99 to high resolution value 254.0

on note
  print("key " & EVENT_KEY & ", velocity " & EVENT_VEL)
end on

on release
  print("key " & EVENT_KEY & " was released")
end on

on note
  if EVENT_KEY < 60
    ignore_event(EVENT_ID) 'do not play notes below middle C
  end if
end on

on note
  new_note(EVENT_KEY + 7, EVENT_VEL, 0, -1) 'add a 5th interval to all notes
end on

on note
  delay_ppq(960)
  release_note(EVENT_ID) 'end all notes after one beat
end on

on note
  send_midi_out(MIDI_COMMAND_NOTE_ON + EVENT_CHAN, EVENT_KEY, EVENT_VEL)
end on

on release
  send_midi_out(MIDI_COMMAND_NOTE_OFF + EVENT_CHAN, EVENT_KEY, EVENT_RELEASE_VEL)
end on

on controller
  if EVENT_CC < 120 'only forwarding performance controllers
    send_midi_out(MIDI_COMMAND_CC + EVENT_CHAN, EVENT_CC, CC[EVENT_CC])
  end if
end on

on note
  id = trigger_new_event()
  print("triggered new event " & id)
end on

on new_event
  print("handle new event " & EVENT_ID)
end on

on init
  var lastNote
end on

on note
  if voices_playing(lastNote)
    ignore_event(EVENT_ID) 'don't play if previous note is still playing
  else
    lastNote = EVENT_ID
  end if
end on

on note
  set_key(EVENT_ID, EVENT_KEY + 12) 'play an octave higher
end on

on note
  set_vel(EVENT_ID, EVENT_VEL + 50) 'play much louder
end on

on note
  set_tune(EVENT_ID, 100000, 0) 'pitch up by 1 semitone
end on

on note
  set_pan(EVENT_ID, random(-1000, 1000)) 'random pan
end on

on note
  set_vol(EVENT_ID, -12000) 'play 12 dB quieter
end on

on note
  fade_in(EVENT_ID, 1000000) 'all notes have a 1 second fade in
end on

on note
   fade_out(EVENT_ID, 1000000, 1) 'all notes have a 1 second fade out then stop
end on

on note
   set_event_param(EVENT_ID, EVENT_PARAM_0, random(0, 1000000)) 'can use value as mod source
end on

on release
  env = get_event_param(EVENT_ID, EVENT_PARAM_0) 'read value set by an envelope follower
  'now do something with the value...
end on

on release
  if get_event_tags(EVENT_ID) == TAG_1
    'do something if only tag 1 is set
  else if get_event_tags(EVENT_ID) .and. TAG_3
    'do something if tag 3 (and maybe other tags) are set
  end if
end on

on init
  prop_stepped Mapping
  add_step(Mapping, "1")
  add_step(Mapping, "2")
  add_step(Mapping, "3")
  add_step(Mapping, "4")
end on

on note
  'add an offset to the Group Alternate Mapping parameter
  set_event_param(EVENT_ID, EVENT_PARAM_ALT_MAPPING, Mapping)
end on

on note
  if EVENT_KEY < 60
    tag_event(EVENT_ID, TAG_1)  'tag any notes below middle C
  end if
end on

untag_event(event, TAG_1 + TAG_2 + TAG_2 + TAG_4) 'remove the first 4 tags if set

on controller
  if EVENT_CC = 1
    set_pan(tagged_events(TAG_1), 8 * CC[1]) 'modwheel pans events tagged with TAG_1
  end if
end on

on note
  group_off(EVENT_ID, ALL_GROUPS)
  group_on(EVENT_ID, CC[1]/32) 'play only group 0,1,2 or 3 depending on modwheel position
end on

set_module_param(M_MAPPING+mappingIndex, 0, 0, 2, loaded)

on note 'for every note
  delay(100000) 'wait 100 ms
  new_note(EVENT_KEY, EVENT_VEL, 0, -1)  'then add another identical note
end on

on note 'for every note
  delay(100) 'wait ~100 ms
  'do something that needs doing but the exact time is not critical
end on

on note 'for every note
  delay(240) 'wait one 16th note
  new_note(EVENT_KEY, EVENT_VEL, 0, -1)  'then add another identical note
end on

on init
  var currentCallback
end on

on note 'for each new note
  end_delay(currentCallback, 0) 'if previous octave note did not play yet, play it now
  currentCallback = CALLBACK_ID 'remember this is now the callback with a delay
  delay(1000000)                              'wait 1 second
  new_note(EVENT_KEY + 12, EVENT_VEL, 0, -1)  'play a note an octave higher
end on

on transport
  if not SONG_PLAYING
    release_note(ALL_NOTES)  'release all notes when transport stops
  end if
end on

var a[3] = (1, 2, 3)
var b[3] = (1, 2, 4)
var x = array_equal(a, b) 'x is 0 as arrays have different contents

array_fill(0, myArray[10], 20) 'fill myArray indexes 10 to 30 with value 0
array_fill(myArray[10], myArray[0], 100) 'shift myArray contents 10 positions to the left
array_fill(array1[100], myArray[0], 10) 'copy 10 values starting at array1[100] into myArray

var myArray[3] = (1, 2, 3)
var x = array_find(myArray, 2) 'x is 1 as 2 was found at array index 1

var myArray[3] = (7, 8, 9)
var x = array_find)_max(myArray, 2) 'x is 8 (the highest of the first 2 values)

var myArray[3] = (7, 8, 9)
var x = array_find_min(myArray[1], 2) 'x is 8 (the lowest of the two values starting at index 1)

var myArray[5] = (1, 2, 3, 4, 5)
var x = array_find_range(myArray[1], 5, 3) 'x is -1 as the value 5 was not found in the 3 values starting at index 1

var array[8] = (1, 2, 3, 4, 1, 2, 0, 4)
var notes[32] = ( 60, 64, 67, 0 )
var x = array_find_difference(array, array[4]) 'x is 2 as the value at array[2] is different to the value at array[4 + 2]
x = array_find_difference(array, notes) 'x is 0 as the value at array[0] is different to the value at notes[0]
x = array_find_difference(notes[10], notes[20]) 'x is -1 as no differences were found comparing notes[10] onwards with notes[20] onwards because all the values are zero

var myArray[10]
var x = array_length(myArray) 'sets x to 10

var myArray[3] = (3, 1, 2)
array_sort(myArray, 0) 'myArray now contains (1, 2, 3)

const ArraySize = 3
var myArray[ArraySize] = (1, 2, 3)
print(array_sum(myArray, 0, ArraySize)) 'should print 6

on init
  prop_text String
end on

on String
  print(character_code(String, 0) 'print first character when string changes
end on

 var heldKeys[12] = { 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0) 'C major chord
 var root
 var chord = identify_chord(root, heldKeys) 'now chord is 1 and root is 0

 on init
   var root
   var bass
   var mask
 end on

 on chord_changed
   root = HOST_CHORD .and. 15 '0 to 11
   bass = (HOST_CHORD >> 8) .and. 15 '0 to 11
   mask = (HOST_CHORD >> 16) 'bit set for each held key relative to root key
   print("Chord root " & root & ", bass " & bass & ", mask" & mask)  
 end on

on midi_drag
  MIDI_DRAG_DATA[0] = 0 'at start tick
  MIDI_DRAG_DATA[1] = (MIDI_COMMAND_NOTE_ON << 16) + (60 << 8) + 100 'note on, key 60, vel 100
  MIDI_DRAG_DATA[2] = 960 'at one quarternote
  MIDI_DRAG_DATA[3] = (MIDI_COMMAND_NOTE_ON << 16) + (60 << 8) 'note off
end on

on io_changed
  print("Output " & BUS_INDEX & " connected = " & BUS_CONNECTED)
end on