###############################################################
#baballe
#enhanced
###############################################################

#dependency
###############################################################
from vector import *
from collision import *

#container
###############################################################
class baballe:
    def __init__(self,x,y,mass=1.0,radius=1.0):
        self.pos = vector(x,y)
        self.mv = vector(0,0)
        self.mass = 1.0/mass
        self.radius = 1
        print self.mass

class gelatine:
    def __init__(self,a,b):
        self.a = a
        self.b = b
        self.distsq = Vdistsq(a.pos,b.pos)

#function
###############################################################

def babForce(babl,vforce):
    #babl.mv = Vsub(VmulScale(vforce,babl.mass),babl.mv)
    babl.mv = VmulScale(Vsub(vforce,babl.mv),babl.mass)

def correct(l,power=0.9):
    distsq = Vdistsq(l.a.pos, l.b.pos)
    delta = Vsub(l.a.pos, l.b.pos)
    if l.distsq != distsq:
        ratio = (l.distsq-distsq)/(2*l.distsq)
        ratio = ratio * power
        #l.a.mv = VmulScale(Vadd(l.a.mv,VmulScale(delta,ratio)),l.a.mass)
        #babForce(l.a,VmulScale(delta,ratio))
        #l.b.mv = VmulScale(Vadd(l.b.mv,VmulScale(delta,-ratio)),l.b.mass)
        #babForce(l.b,VmulScale(delta,-ratio))
        l.a.mv = Vadd(l.a.mv,VmulScale(delta,ratio*l.a.mass))
        l.b.mv = Vadd(l.b.mv,VmulScale(delta,-ratio*l.b.mass)) 

    
#test
###############################################################

if __name__ == "__main__":
    import pyg
    
    col1 = vector(0,512)
    col2 = vector(1024,385)
    origin = vector(1024,512)
    col3 = vector(0,256)
    col4 = vector(256,512)
    origin2 = vector(0,512)
    
    b = box(0,0,pyg.width,pyg.height)
    
    p = []
    p.append(baballe(100,100,1.6,2))
    p.append(baballe(100,200,1.6,4))
    p.append(baballe(200,100,1.6,6))
    p.append(baballe(200,200,1.6,8))
    p[0].mv.x = 0
    p[0].mv.x = 0.5
    p[0].mv.x = 1.5
    p[0].mv.x = 2.9
    
    l = []
    l.append(gelatine(p[0],p[1]))
    l.append(gelatine(p[1],p[2]))
    l.append(gelatine(p[2],p[0]))
    l.append(gelatine(p[3],p[2]))
    l.append(gelatine(p[3],p[1]))
    l.append(gelatine(p[3],p[0]))
    
    vertical = vector(0,1)
    horizontal = vector(1,0)
    
    while pyg.main():
        for i in p:
            i.mv.y += 0.5
            #collision detection
            dest = Vadd(i.pos,i.mv)
            if not VinBox(dest,b):
                i.mv = vector(0,0)
            elif collidePointLineSQ(dest,origin,col1,col2):
                newdest = VLineIntersect(i.pos,dest,col1,col2)
                closest = VclosestPoint(dest,col1,col2)
                i.pos = newdest
                #babForce(i,Vsub(closest,newdest))
                i.mv = vector(0,0)
            elif collidePointLineSQ(dest,origin2,col3,col4):
                newdest = VLineIntersect(i.pos,dest,col3,col4)
                closest = VclosestPoint(dest,col3,col4)
                i.pos = newdest
                #babForce(i,Vsub(closest,newdest))
                i.mv = vector(0,0)
            else:
                i.pos = dest


            
            pyg.circle(i.pos.x,i.pos.y,i.radius)

        for i in l:
            #correctJello(i,0.06)
            #jello power < 0.01
            #hard power ~ 0.9
            correct(i,0.6)
            
            pyg.line(i.a.pos.x, i.a.pos.y, i.b.pos.x, i.b.pos.y,(0,0,255))

        pyg.line(col1.x, col1.y, col2.x, col2.y,(255,0,0))
        pyg.line(col3.x, col3.y, col4.x, col4.y,(0,255,0))