atom
    vector pos
    vecotr mv
    float mass
    float radius

structure
Qnode
    atomLst[];
    int atomQty;
    Qnode parent;
          nw, 
          ne,
          sw, 
          se;


quadTree
   float size;  //same for w and h, square world
   Qnode root;
   int nLayer;


//size at layer = w/(layer+1)

void insert(quadTree qt, atom a)
    //find proper layer
    layer = findLayer(qt,a);
    //find the proper node to insert
    node = findQuadran(qt.root, a.pos, layer, qt.size );
    //insert in list
    node.atomLst[node.atomQty++] = a;

int findLayer(quadTraa qt, atom a)
    layer = qt.nLayer;
    while(2*atom.radius > qt.size/(layer+1))
        layer--;
    return layer;

Qnode findQuadran(Qnode parent, vector pos, layer, size)
    if pos.x < size/2
        if pos.y < size/2
            if layer
                return findQuadran(nw,pos,layer-1, size/2)
            else
                return nw;
        else
            if layer
                return findQuadran(sw,pos-vector(0,size/2),layer-1, size/2)
            else
                return sw;
    else
        if pos.y < size/2
            if layer
                return findQuadran(ne,pos-vector(size/2,0),layer-1, size/2)
            else
                return ne;
        else
            if layer
                return findQuadran(se,pos-vector(size/2,size/2),layer-1, size/2)
            else
                return se;

atom [] getLeaves(Qnode root)
    if root
        return root.atomLst + 
               getLeaves(root.ne) + 
               getLeaves(root.se) +
               getLeaves(root.nw) + 
               getLeaves(root.sw);
    return []

atom [] getAbove(Qnode leave)
    if leave
        return leave.atomLst +
               getAbove(leave.parent);
    return []

atom [] getCollisionListFromQuadTree(quadTree qt, atom a)
    //return every atom from lower list
    //and return only upper node atom in direct path
    atom atomLst[]
    int atomQty;
    int layer = findLayer(qt,a);
    Qnode origin = findQuadran(qt.root, a.pos, layer, qt.size)
    atomLst += getLeaves(origin);
    atomLst += getAbove(origin.parent);
    
    
    
functional array concatenator


T[] concat(T[] A, T[] B) {
   T[] C= new T[A.length+B.length];
   System.arraycopy(A, 0, C, 0, A.length);
   System.arraycopy(B, 0, C, A.length, B.length);

   return C;
}

atom getAtomClose(quadTree qt, atom a, int index)
{
    int layer = findLayer(qt, a);
    Qnode origin = findNode(qt.root, a.pos, layer, qt.size);
    if
}
