###############################################################
#pong
#simple point in space with no physic
###############################################################

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

#container
###############################################################
class pong:
    def __init__(self,x,y):
        self.pos = vector(x,y)
        self.mv = vector(10,0)

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

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

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

           #r = (distance - link(n).RL) * link(n).K
        #force = vectormul(linkvector, r)
    if l.distsq != distsq:
        r = (distsq - l.distsq)*0.005
        print r
        l.a.mv = Vadd(l.a.mv, VmulScale(delta, r))
        l.b.mv = Vadd(l.b.mv, VmulScale(delta, -r))
##        force = vectorsub2(atom(link(n).A).v, atom(link(n).B).v)'spring damping
##        force = vectorneg(force)
##        force = vectormul(force, link(n).D)
        deltavel = Vadd(l.a.mv, l.b.mv)
        deltavel.x = -deltavel.x
        deltavel.y = -deltavel.y
        l.a.mv = Vadd(l.a.mv, VmulScale(deltavel,power))
        l.b.mv = Vadd(l.b.mv, VmulScale(deltavel, -power))
# dist = distance(ap,bp)
# Vdelta = ap - bp
# ratoi = (restdist-dist) / (2*restdist)
# nva = va + Vdelta*ratio
# nvb = vb + Vdelta*-ratio


#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(pong(100,100))
    p.append(pong(100,200))
    p.append(pong(200,100))
    p.append(pong(200,200))
    
    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.1
            #collision detection
            #vertical
            dest = Vadd(i.pos,Vmul(i.mv,vertical))
            if (collidePointLineSQ(dest,origin,col1,col2)) and VinBox(dest,b) and collidePointLineSQ(dest,origin2,col3,col4):
                i.pos = dest
            else:
                #i.mv = Vmul(i.mv,horizontal)
                i.mv = vector(i.mv.x*1, i.mv.y*-0.2)
            #horizontal
            dest = Vadd(i.pos,Vmul(i.mv,horizontal))
            if (collidePointLineSQ(dest,origin,col1,col2)) and VinBox(dest,b) and collidePointLineSQ(dest,origin2,col3,col4):
                i.pos = dest
            else:
                #i.mv = Vmul(i.mv,vertical)
                i.mv = vector(i.mv.x*-0.2, i.mv.y*1)
            pyg.circle(i.pos.x,i.pos.y)

        for i in l:
            #correctJello(i,0.06)
            #jello power < 0.01
            #hard power ~ 0.9
            #correct(i,0.000000005)
            correct(i,0.0005)
            
            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))