require 'ruby2d'

# 1. Надання значень параметрам моделі 
r0=5   # початковий радіус кругів
n=40    # початкова кількість кругів
vmax=10 # верхня межа проекції швидкості
w=360   # розмір вікна по горизонталі
h=360   # розмір вікна по вертикалі

# 2. Структура даних - масиви:
m=[1*n] # маси
r=[1*n] # радіуси
x=[0*n] # абсциси
y=[0*n] # ординати
vx=[0*n]# складова швидкості по горизонталі
vy=[0*n]# складова швидкості по вертикалі
img=[0*n]# створені образи

# 3. Встановлення параметрів вікна
set title: "Модель взаємодії",# заголовок
    width:  w,                # ширина
    height: h                 # висота

# 4. Надання початкових випадкових значень
#                  коодинатам і швидкостям 
x[0]=r0+(w-2*r0)*rand
y[0]=r0+(h-2*r0)*rand
m[0]=1 
r[0]=r0
vx[0]=(2*rand-1)*vmax 
vy[0]=(2*rand-1)*vmax
for j in 1...n do
  m[j]=1 
  r[j]=r0
  vx[j]=(2*rand-1)*vmax 
  vy[j]=(2*rand-1)*vmax
  x[j]=0
  while x[j]==0 
    x[j]=r0+rand*(w-2*r0)
    y[j]=r0+rand*(h-2*r0)
    k=0
    while (((x[j]-x[k])*(x[j]-x[k])+(y[j]-y[k])*(y[j]-y[k])>4*r0*r0) && (k<j) ) do
      k=k+1 # поки круги j, k не перетинаються
    end
    if k<j then
      x[j]=0
    end
  end  
end

# 5. Відображення початкового стану
for j in 0...n do
  img[j]=Image.new(x:x[j]-r[j], y:y[j]-r[j],
    z:0, width:r[j]*2, height:r[j]*2,
    path:"ball.png", color:"green")
end

t=0
update do
 t=t+1
 if ((t&5) == 0) then 
  j=0
  for j in 0...n do

# 6.Прямолінійний рівномірний рух
    x[j]=x[j]+vx[j] 
    y[j]=y[j]+vy[j]

# 7. Відбивання від країв
    if (x[j]<r[j]) then
        x[j]=r[j]*2-x[j]
        if vx[j]<0 then
           vx[j]=-vx[j]
        end
    end
    if (y[j]<r[j]) then
        y[j]=r[j]*2-y[j]
        if vy[j]<0 then 
           vy[j]=-vy[j]
        end
    end
    if (x[j]> w-r[j]) then
        x[j]=(w-r[j])*2-x[j]
        if vx[j]>0 then  
           vx[j]=-vx[j]
        end
    end
    if (y[j]> h-r[j]) then
        y[j]=(h-r[j])*2-y[j]
        if vy[j]>0 then 
           vy[j]=-vy[j] 
        end
    end

# 8.Відображення прямолінійного рівномірного
#   руху і відбивання від меж
    img[j].x=x[j]-r[j]
    img[j].y=y[j]-r[j]
  end
  j=0

# 9. Перебір усіх можливих пар кругів і
#    їхнє злиття за умови їхнього перетину  
  while ((j<n-1) && (0<n)) do
    k=j+1
    while (k<n) do
      if ((x[j]-x[k])*(x[j]-x[k])+(y[j]-y[k])*(y[j]-y[k]) <= (r[j]+r[k])*(r[j]+r[k])) then

# 10. Закон збереження імпульсу
        vx[j]=(vx[j]*m[j]+vx[k]*m[k])/(m[j]+m[k])
        vy[j]=(vy[j]*m[j]+vy[k]*m[k])/(m[j]+m[k])

# 11. Координати центра мас як усереднення
#     кооординат
        x[j] =(x[j]*m[j]+x[k]*m[k])/(m[j]+m[k])
        y[j] =(y[j]*m[j]+y[k]*m[k])/(m[j]+m[k])

# 12. Закон збереження маси
        m[j]=m[j]+m[k]

# 13. Маса пропорційна площі - квадрату радіуса
        r[j]=r0*Math.sqrt(m[j])

# 14. Зменшення кількості дисків після злиття
        m[k]=m[n-1]
        r[k]=r[n-1]
        x[k]=x[n-1]
        y[k]=y[n-1]
        vx[k]=vx[n-1]
        vy[k]=vy[n-1]
        img[n-1].width=0
        img[n-1].height=0
        n=n-1
        k=k-1

# 15. Відбивання від країв після злиття
        if (x[j]<r[j]) then
            x[j]=r[j]*2-x[j]
            if vx[j]<0 then
               vx[j]=-vx[j]
            end
        end
        if (y[j]<r[j]) then
            y[j]=r[j]*2-y[j]
            if vy[j]<0 then 
               vy[j]=-vy[j]
            end
        end
        if (x[j]> w-r[j]) then
            x[j]=(w-r[j])*2-x[j]
            if vx[j]>0 then  
               vx[j]=-vx[j]
            end
        end
        if (y[j]> h-r[j]) then
            y[j]=(h-r[j])*2-y[j]
            if vy[j]>0 then 
               vy[j]=-vy[j] 
            end
        end

# 16. Відображення дисків після злиття
        img[j].x=x[j]-r[j]
        img[j].y=y[j]-r[j]
        img[j].width=r[j]*2
        img[j].height=r[j]*2
        img[k].x=x[k]-r[k]
        img[k].y=y[k]-r[k]
        img[k].width=r[k]*2
        img[k].height=r[k]*2
      end
      k=k+1
    end
    j=j+1
  end
 end 
end

show