Micro drum sequencer

sound_freq = 22050
tick_len = 3000
channels = 1
cell_size = 16
xcells = 8
ycells = 8
cells = new_array( xcells * ycells )
sound = new_string( tick_len * xcells )
xcells_changes = new_array( xcells )
volume = 64
dmode = 0
 
sound_id = send_sound( sound, sound_freq, channels, 1 )
sound_volume( 128 )
 
prev_p = -9999
 
start:
clear( BLACK )
 
p = 0 while( p < xcells ) { xcells_changes[ p ] = 0 p + 1 }
 
xxx = -( cell_size * xcells ) / 2
yyy = -( cell_size * ycells ) / 2
 
p = 0
y = 0 while( y < ycells )
{
	x = 0 while( x < xcells ) 
	{
		cx = x * cell_size - ( ( cell_size * xcells ) / 2 )
		cy = y * cell_size - ( ( cell_size * ycells ) / 2 )
		handle_pen_keys( HANDLE_PEN, HANDLE_PEN, { prev_p = -9999 } )
		if cells[ p ] >= 0 { c = get_blend( #203920, RED, cells[ p ] * 8 ) }
		if cells[ p ] < 0 { c = get_blend( #203920, BLUE, -cells[ p ] * 8 ) }
		fbox( cx+1, cy+1, cell_size-1, cell_size-1, c )
		x + 1
		p + 1
	}
	y + 1
}
handle_pen_keys( HANDLE_PEN2_click, HANDLE_PEN2_move, { prev_p = -9999 } )
 
print( "DRAW MODE $dmode", xxx, yyy - 9, WHITE )
print( "VOL", xxx - 26, volume - 9, WHITE )
line( -1000, volume, xxx - 2, volume, WHITE )
p = 0 x = xxx - 2 xs = -get_pixi_xsize(0) / 2
spos = get_sound_status( sound_id )
xpos = spos / tick_len xpos = xpos * cell_size fbox( xxx + xpos, -yyy + 1, cell_size-1, cell_size-1, WHITE )
while( x > xs ) {
	vv = sound[ spos + p ]
	if vv < 0 { vv = -vv }
	vv * 2
	v = vv / 8
	dot( x, volume + v + 2, get_color( vv*8, vv*4, vv ) )
	x - 2 p + 8
}
 
//RENDER SOUND: //////////////////////////
p = 0
x = 0 while( x < xcells ) {
	if xcells_changes[ x ] {
		//CLEAN TICK:
		pp = p while( pp < p + tick_len ) { sound[ pp ] = 0 pp + 1 }
		y = 0 while( y < ycells )
		{
			v = cells[ y * xcells + x ]
			if v {
// SYNTH Y. RENDER ONE TICK: /////////////
if v > 0 {
vol = ( 2048 * v ) / 32
if y = 0 {
	pp = p while( pp < p + tick_len ) { 
		sound[ pp ] = sound[ pp ] + ( ( rand & 31 ) * vol ) / 2048
		vol - 1 if vol < 0 { vol = 0 }
		pp + 1 
	}
}
if y = 1 {
	pp = p while( pp < p + tick_len ) { 
		sound[ pp ] = sound[ pp ] + ( ( ( ( rand & 31 ) * csin(pp/4) ) / 256 ) * vol ) / 2048
		pp + 1 
	}
}
if y = 2 {
	pp = p while( pp < p + tick_len ) { 
		sound[ pp ] = sound[ pp ] + ( ( rand & 31 ) * vol ) / 2048
		vol - 5 if vol < 0 { vol = 0 }
		pp + 1 
	}
}
if y = 3 {
	pp = p while( pp < p + tick_len ) { 
		sound[ pp ] = sound[ pp ] + ( (csin(sin(pp)*4)/4) * vol ) / 2048
		vol - 1 if vol < 0 { vol = 0 }
		pp + 1 
	}
}
if y = 4 {
	pp = p while( pp < p + tick_len ) { 
		sound[ pp ] = sound[ pp ] + ( (csin(sin(pp)*8)/4) * vol ) / 2048
		vol - 1 if vol < 0 { vol = 0 }
		pp + 1 
	}
}
if y = 5 {
	pp = p while( pp < p + tick_len ) { 
		sound[ pp ] = sound[ pp ] + ( (csin(sin(pp)*64)/4) * vol ) / 2048
		vol - 3 if vol < 0 { vol = 0 }
		pp + 1 
	}
}
if y = 6 {
	pp = p while( pp < p + tick_len ) { 
		sound[ pp ] = sound[ pp ] + ( (csin(sin(pp/8)*64)/4) * vol ) / 2048
		vol - 1 if vol < 0 { vol = 0 }
		pp + 1 
	}
}
if y = 7 {
	pp = p while( pp < p + tick_len ) { 
		sound[ pp ] = sound[ pp ] + ( (csin(sin(pp/16)*13)/4) * vol ) / 2048
		vol - 1 if vol < 0 { vol = 0 }
		pp + 1 
	}
}
} else {
	//v < 0:
vol = ( 2048 * -v ) / 32
	pp = p while( pp < p + tick_len ) { 
		sound[ pp ] = sound[ pp ] + ( ( csin(sin(pp/2)*y)/4 ) * vol ) / 2048
		vol - 1 if vol < 0 { vol = 0 }
		pp + 1 
	}
}
//////////////////////////////////////////
			}
			y + 1
		}
	}
	x + 1
	p + tick_len
}
//////////////////////////////////////////
 
frame( 0 )
go start
 
HANDLE_PEN:
if gpr( cx, cy, cell_size, cell_size ) {
	if p != prev_p { 
		if dmode = 1 { cells[ p ] = volume / 2 }
		if dmode = 0 {
			if cells[ p ] = 0 { cells[ p ] = volume / 2 } else { cells[ p ] = 0 }
		}
		xcells_changes[ x ] = 1 
	}
	prev_p = p
}
ret
 
HANDLE_PEN2_click:
if ( gpx < xxx ) & ( prev_p < -1000 ) { 
	//SET VOLUME:
	volume = gpy
	if volume > 64 { volume = 64 }
	if volume < -64 { volume = -64 }
}
if ( gpy < yyy ) & ( prev_p < -1000 ) { 
	dmode + 1
	dmode = dmode & 1
}
ret
 
HANDLE_PEN2_move:
if ( gpx < xxx ) & ( prev_p < -1000 ) { 
	//SET VOLUME:
	volume = gpy
	if volume > 64 { volume = 64 }
	if volume < -64 { volume = -64 }
}
ret