Разные эффекты

Разные эффекты

Здесь собраны эффекты не использующие внешних файлов

Автор: intre

Снег

SCREEN_WIDTH = 240
SCREEN_HEIGHT = 320
resize_pixi(0, SCREEN_WIDTH, SCREEN_HEIGHT)
X=0 Y=1 DX=2 DY=3 COLOR=4 SIZE=5
COUNT = 1000
sneg = new_array(COUNT*SIZE)
bg = new_pixi(SCREEN_WIDTH, SCREEN_HEIGHT, 1)
init_sneg
pixi(bg, 0, 0)
i = 0
while(1){
   transp(128)
   pixi(bg, 0, 0)
   transp(256)
   draw_sneg
   move_sneg
   i+1
   frame(50)
}
 
init_sneg:
   L = SCREEN_WIDTH*SCREEN_WIDTH+SCREEN_HEIGHT*SCREEN_HEIGHT
   sqrt
   c = rslt
 
   x = 0   // init background
   while(x < SCREEN_WIDTH){
      y = 0
      while(y < SCREEN_HEIGHT){
         bg[y*SCREEN_WIDTH+x] = BLACK
         y+1
      }
      x+1
   }
 
   n = 0   // init snow
   while(n < COUNT){
      sneg[n*SIZE+X] = rand*(SCREEN_WIDTH)/32767 - SCREEN_WIDTH/2
      sneg[n*SIZE+Y] = rand*(SCREEN_HEIGHT)/32767 - SCREEN_HEIGHT/2
      sneg[n*SIZE+DX] = rand*3/32767+1
      sneg[n*SIZE+DY] = rand*3/32767+1
      point
      sneg[n*SIZE+COLOR] = col
      n+1
   }
ret
 
draw_sneg:
   n = 0
   while(n < COUNT){
      dot(sneg[n*SIZE+X], sneg[n*SIZE+Y], sneg[n*SIZE+COLOR])
      n+1
   }
ret
 
move_sneg:
   n = 0
   while(n < COUNT){
      sneg[n*SIZE+X] = sneg[n*SIZE+X]+(sneg[n*SIZE+DX])
      sneg[n*SIZE+Y] = sneg[n*SIZE+Y]+(sneg[n*SIZE+DY])
      if sneg[n*SIZE+X] > SCREEN_WIDTH/2 {   // check x
         sneg[n*SIZE+X] = -SCREEN_WIDTH/2
         sneg[n*SIZE+DX] = rand*3/32767+1
      }
      if sneg[n*SIZE+Y] > SCREEN_HEIGHT/2 {   // check y
         sneg[n*SIZE+Y] = -SCREEN_HEIGHT/2
         sneg[n*SIZE+DY] = rand*3/32767+1
      }
      n+1
   }
ret
 
sqrt:
   rslt = L
   div = L
   if L <= 0 { ret }
   while (1){
      div = (L / div + div) / 2
      if rslt > div { rslt = div }
      else { ret }
   }
ret
 
point:
   r = 256 - rand*100/32767
   col = get_color(r, r, r)
ret

Солнце (алгоритм вычисления квадратного корня)

Раскрыть код

SCREEN_WIDTH = 240
SCREEN_HEIGHT = 320
resize_pixi(0, SCREEN_WIDTH, SCREEN_HEIGHT)
 
img = new_pixi(SCREEN_WIDTH, SCREEN_HEIGHT, 1)
L = (SCREEN_WIDTH/2)*(SCREEN_WIDTH/2) + (SCREEN_HEIGHT/2)*(SCREEN_HEIGHT/2)
sqrt
max = rslt
 
COLOR1 = RED
COLOR2 = YELLOW
 
i = 0
while(1){
   clear(SNEG)
 
   COLOR = get_blend(COLOR1, COLOR2, ccos(i)+128)
   x = 0
   while(x < SCREEN_WIDTH){
      y = 0
      while(y < SCREEN_HEIGHT){
         L = (x-SCREEN_WIDTH/2)*(x-SCREEN_WIDTH/2) + (y-SCREEN_HEIGHT/2)*(y-SCREEN_HEIGHT/2)
         sqrt
         img[y*SCREEN_WIDTH+x] = rslt*COLOR/max
         y+1
      }
      x+1
   }
   pixi(img, 0, 0)
 
   i+1
   frame(50)
}
 
 
//Алгоритм вычисления квадратного корня
sqrt:
   rslt = L
   div = L
   if L <= 0 { ret }
   while (1){
      div = (L / div + div) / 2
      if rslt > div { rslt = div }
      else { ret }
   }
ret

Автор: Alex Zolotov (NightRadio)

Торнадо

start_timer(0)
l:
transp(16)
clear(BLACK)
t=get_timer(0)
t_reset
t_rotate_z( t/28 )
c = rand&255
transp(256)
dot(,,get_color(c+128,c+64,c))
transp(128)
pixi(0,0,1,2) pixi(0,-1,0) pixi(0,0,-1)
frame(50)
go l

While

start_timer( 0 )
 
start:
 
t = get_timer( 0 ) / 16
 
effector( 0, 32, 1, -800, -800, 1600, 1600, 1 )
effector( 0, 32, 2, -800, -800, 1600, 1600, 1 )
 
y = -64 while( y < 64 ) 
{
	x = -64 while( x < 64 ) 
	{
		dot( x, y, get_color( csin( x + ccos( x+y+t ) + t*2 ) + 80, ccos( y+x + t*3 ) + 90, csin( x + 80 + t ) + 40 ) )
		x + 1
	}
y + 1
}
 
frame
go start

Blobs

clear( BLACK )
MAKE_BLOB
 
start:
x = ( rand%320 ) - 160
y = ( rand%240 ) - 120
pixi( BLOB_IMG, x, y, rand&3, 0 )
frame( 50 )
go start
 
MAKE_BLOB:
BLOB_SIZE = 64
if BLOB_IMG = 0 
{ 
	BLOB_IMG = new_pixi( BLOB_SIZE, BLOB_SIZE, 1 ) 
	pixi_alpha( BLOB_IMG, BLOB_IMG )
	p = 0
	y = 0 while( y < BLOB_SIZE ) {
		x = 0 while( x < BLOB_SIZE ) {
			c1 = cos( ( (x-BLOB_SIZE/2)*2 * 256 ) / BLOB_SIZE ) / 2 + 128
			c2 = cos( ( (y-BLOB_SIZE/2)*2 * 256 ) / BLOB_SIZE ) / 2 + 128
			c = ( c1 * c2 ) / 256
			BLOB_IMG[ p ] = get_color( c, c, c )
			p + 1
			x + 1
		}
		y + 1
	}
}
ret

Blobs_with_zoom

xsize = 320
ysize = 240
 
MAKE_BLOB
 
scr_cnt = 0
scr2 = new_pixi( xsize, ysize, 1 )
 
start:
if scr_cnt = 0 { 
	set_screen( scr2 )
	pixi( 0, 0, 0, 1, 32 )
} else {
	set_screen( 0 )
	pixi( scr2, 0, 0, 1, 32 )
}
scr_cnt + 1
scr_cnt & 1
x = ( rand%xsize ) - xsize/2
y = ( rand%ysize ) - ysize/2
pixi( BLOB_IMG, x, y, rand&3, 0 )
effector( WHITE, 16, 0, -500, -500, 1000, 1000, 0 )
frame( 50 )
go start
 
MAKE_BLOB:
BLOB_SIZE = 64
if BLOB_IMG = 0 
{ 
	BLOB_IMG = new_pixi( BLOB_SIZE, BLOB_SIZE, 1 ) 
	pixi_alpha( BLOB_IMG, BLOB_IMG )
	p = 0
	y = 0 while( y < BLOB_SIZE ) {
		x = 0 while( x < BLOB_SIZE ) {
			c1 = cos( ( (x-BLOB_SIZE/2)*2 * 256 ) / BLOB_SIZE ) / 2 + 128
			c2 = cos( ( (y-BLOB_SIZE/2)*2 * 256 ) / BLOB_SIZE ) / 2 + 128
			c = ( c1 * c2 ) / 256
			BLOB_IMG[ p ] = get_color( c, c, c )
			p + 1
			x + 1
		}
		y + 1
	}
}
ret

Автор: ZUF

Stars

Раскрыть код

///// STARFIELD CONFIG /////
frame_speed = 1		// ms Между кадрами
speed = 2		// скорость полета сквозь звезды (рекомендуемое значение = 1)
line_lengs=7		// Длина линии (размазанная звезда)
stars_count = 3000
max_brightness = 235	// Максимальная яркость звезды
//zoom(2)
word_display_time=6000 // in ms
//////////////////
 
str_show_time=0
 
rand_seed(get_seconds)
 
px = new_array (stars_count) 
py = new_array (stars_count) 
pz = new_array (stars_count) 
 
i=0
init:
  if (i<stars_count)
  {
    new_star
    pz[i] = (rand)/64
    if (pz[i]<=0) {pz[i]=1}
  }
 
  if (i>=stars_count)
  {
    i=0
    start_timer(1)
    clear(0)
    go main
  }
 
  i=i+1
go init
 
main:
//clear(0)
 
  begin_cycle:
  if (pz[i]=0)
{
//print( "pz[i]=0", 0, -100, #FFFFFF )
//stop 
}
 
  x = px[i]/pz[i]
  y = py[i]/pz[i]
  z = (pz[i]+line_lengs)
  if (z=0){z=1}
  xl = px[i]/z
  yl = py[i]/z
 
  color_t = max_brightness-pz[i]
  color = get_color( color_t, color_t, color_t )
  //dot (x, y, color)  
  line (x,y,xl,yl,color )
 
  pz[i] = pz[i] - speed
  if (pz[i] < speed*4) 
  {
    new_star
  }
 
  i = i + 1
  if (i>(stars_count-line_lengs-1))
  {
   i=0
   clear(0)
  }
  if (i<(stars_count-line_lengs-1))
  {
   go begin_cycle
  }
 
  ystr = get_string_size(str_num)/(-2)*8
  ystr2 = ystr+1
  //print(str_num, ystr2, 1, #000000 )
  //print(str_num, ystr, 0, #FFFFFF )
 
 
frame(frame_speed)
go main
 
new_star:
   px[i] = (32768/2-rand)*4
   py[i] = (32768/2-rand)*3
   pz[i] = max_brightness
ret

Автор: vtl

#1

Раскрыть код

//------------------------------------------------------------
 
draw_stripes:
 
  if (alpha > 256)
  {
    alpha = 0
  }
 
  i = num - 1
  while(i >= 0)
  {
    offset = csin(alpha + deltas[ i ]) * amp / 128
    grad_y1 = -20 + offset
    grad_y2 = 20 + offset
 
    grad_col1 = colors1[ i ]
    grad_col2 = colors2[ i ]
    double_grad
 
    i - 1
  }
 
  alpha + dalpha
 
ret
 
//------------------------------------------------------------
//инициализация всего и вся
//------------------------------------------------------------
 
init_vars:
 
  num = 5
  deltas = new_array(num)
  colors1 = new_array(num)
  colors2 = new_array(num)
  bar_h = h / 8
  dalpha = 2
  alpha = 0
  grad_steps = 10
  amp = h / 2 - bar_h / 2
 
  i = 0
  while(i < num)
  {
    deltas[ i ] = -bar_h * i / 2
    i + 1
  }
 
  colors1[ 0 ] = #5F0000
  colors2[ 0 ] = #FF1010
  colors1[ 1 ] = #005F00
  colors2[ 1 ] = #10FF10
  colors1[ 2 ] = #00005F
  colors2[ 2 ] = #1010FF
  colors1[ 3 ] = #5F5F00
  colors2[ 3 ] = #FFFF10
  colors1[ 4 ] = #5F005F
  colors2[ 4 ] = #FF10FF
 
ret
 
//------------------------------------------------------------
//зеркальный градиент
//------------------------------------------------------------
 
double_grad:
 
  temp1 = grad_steps
 
  grad_steps / 2
  grad_y2 = grad_y1 + (grad_y2 - grad_y1) / 2
  vert_grad
 
  temp2 = grad_y2 - grad_y1
  grad_y1 = grad_y2
  grad_y2 = grad_y1 + temp2
  temp2 = grad_col1
  grad_col1 = grad_col2
  grad_col2 = temp2
  vert_grad
 
grad_steps = temp1
 
ret
 
//------------------------------------------------------------
//вертикальный градиент
//------------------------------------------------------------
 
vert_grad:
 
  z = 0
  step_h = (grad_y2 - grad_y1) / grad_steps
  step_c = 255 / (grad_steps - 1)
  while(z < grad_steps)
  {
    fbox(-w / 2, grad_y1 + z * step_h, w, step_h, get_blend(grad_col1, grad_col2, z * step_c) )
    z + 1
  }
 
ret

#2

Раскрыть код

//------------------------------------------------------------
//навеяно darwinia :)
//------------------------------------------------------------
 
h = get_window_ysize
w = get_window_xsize
 
init_vars
 
draw:
 
  clear(0)
  draw_mans
  frame(40)
 
goto draw
 
//------------------------------------------------------------
//рисовать человеков
//------------------------------------------------------------
 
draw_mans:
 
  i = 0
  while (i < num)
  {
    pixi(man, x[i], y[i], sz[i], 0)
    x[i] = x[i] + sp[i]
    if (x[i] > w / 2 + manw * sz[i] / 2 )
    {
      setnew
    }
    i + 1
  }
 
ret
 
//------------------------------------------------------------
//задать все
//------------------------------------------------------------
 
init_vars:
 
  num = 10
  x = new_array(num)
  y = new_array(num)
  sz = new_array(num)
  sp = new_array(num)
  minsp = 1
  maxsp = 11
  minsz = 1
  maxsz = 6
 
  b = #007f00
  s = #00ff00
 
  man = "
...sssss...
...sbbbs...
...sbbbs...
ssssbbbssss
sbbbbbbbbbs
sbbbbbbbbbs
sbbbbbbbbbs
ssssbbbssss
...sbbbs...
ssssbbbssss
sbbbbbbbbbs
sbbbbbbbbbs
sbbbbbbbbbs
sbbbs.sbbbs
sbbbs.sbbbs
sbbbs.sbbbs
sssss.sssss
"
  make_pixi (man)
  manh = get_pixi_ysize(man)
  manw = get_pixi_xsize(man)
 
  i = 0
  while (i < num)
  {
    setnew
    i + 1
  }
 
ret
 
//------------------------------------------------------------
//создать нового человека
//------------------------------------------------------------
 
setnew:
 
  newone
  x[i] = x1
  y[i] = y1
  sp[i] = sp1
  sz[i] = sz1
 
ret
 
//------------------------------------------------------------
//задать новые значения
//------------------------------------------------------------
 
newone:
 
  sz1 = minsz + (maxsz - minsz) * rand / 32767
  sp1 = minsp + (maxsp - minsp) * rand / 32767
  x1 = -w / 2 - manw * sz1 / 2
  y1 = -h / 2 + manh * sz1 / 2 + (h - manh * sz1) * rand / 32767
 
ret

Тема на форуме

Автор: Gekon

xx=get_window_xsize
yy=get_window_ysize
 
x=xx/2
start_x:
y=yy/2
start_y:
color=get_color(sin(2*x),cos(3*y),x*y)
dot(x,y,color)
y=y-1
if y>-yy/2 {go start_y}
x=x-1
if x>-xx/2 {go start_x}
frame(0)