from marioGraphics import *

#initialization
dead = False
win = False
n = 3
d = Designer(900,900,-100,100,100,-100)
d.show()

#variabili di preparazione
ready = False
intens = 1
direzione = 0

#global variables to be shown everywhere (aka images and objects in the viewport)
pianeta = Image("./imgs/pianeta.png",0,0,0.70)
asteroide = Image("./imgs/asteroide.png",90,80,0.25)

radius = Circle(pianeta, 80)
arrowdir = Segment(asteroide,asteroide.x-10,asteroide.y)
gauge = Image("./imgs/1.png",-80,-80,0.25)


def setup():
    #disegnaml
    disegna()

    #preparazione, aspettiamo la decisione
    preparazione()






    #condizione d'uscita
    if(dead or win):
        d.freeze()
        d.destroy()
        del d


def disegna():
    global d
    d.draw(arrowdir)
    d.draw(radius)
    d.draw(gauge)

    d.draw(pianeta)
    d.draw(asteroide)

def gaugeanimation():
    #disegna il gauge in base al valore di intens
    global d
    global gauge
    global intens

    if(intens==1):
        gauge = Image("./imgs/1.png",-80,-80,0.25)
        gauge.draw(d)


    if(intens==2):
        gauge = Image("./imgs/2.png",-80,-80,0.25)
        gauge.draw(d)


    if(intens==3):
        gauge = Image("./imgs/3.png",-80,-80,0.25)
        gauge.draw(d)


    if(intens==4):
        gauge = Image("./imgs/4.png",-80,-80,0.25)
        gauge.draw(d)




def preparazione():
     global ready
     global intens
     global direzione
     while(not ready):
         if d.key:
            if d.key=="Return":
                #siamo pronti!!!
                ready = True
            if d.key=="Right":
                #aumenta angolo
                direzione=0.01
            if d.key=="Left":
                #diminuisci angolo
                direzione=-0.01
            if d.key=="Up":
                #aumenta intensità
                if(intens<4):
                    intens+=1
            if d.key=="Down":
                #diminuisci intensità
                if(intens>1):
                    intens-=1
         update()
         direzione=0
     lancio()

def update():
    global arrowdir   #aggiorna le cose che deve aggiornare
    global radius
    d.tick(0.00000000001)
    arrowdir.rotate(direzione)
    arrowdir.redraw(d)
    radius.redraw(d)
    gaugeanimation()

def lancio():
    global arrowdir
    global asteroide
    global d
    global intens
    global radius

    traiettoria = Line(arrowdir)
    estremo = Point(-100,traiettoria.ordinate(-100))
    #incremento nella direzione in cui è puntato
    if(arrowdir.b.x<arrowdir.a.x):
        incremento = 0.18*intens
    else:
        incremento = -0.18*intens


    #finchè non entra nell'orbita del pianeta
    while(checktraiettoria()):
        asteroide = asteroide.projection(estremo,incremento)
        d.tick(0.01)
        asteroide.draw(d)



    orbita(estremo,incremento)

def checktraiettoria():
    global asteroide
    global radius
    global d
    #controllo che non vada fuori subito

    if(not (asteroide.distance(radius.c)>=radius.r)):
        return False
    if(asteroide.x>100 or asteroide.x <-100 or asteroide.y<-100 or asteroide.y>100):
         d.freeze()
         d.destroy()
         del d
         return False
    return True



def orbita(estremo,incremento):
    #entra in orbita
    global asteroide
    global radius
    global dead
    global d
    accelerazione = 1
    mod = 1 #modulazione velocità tangenziale data dal campo gravitazionale
    correzione = 0



    #controllo orbita

    while(asteroide.distance(radius.c)<radius.r and not dead and asteroide.distance(radius.c)>radius.r/3):

        #rapporto incrementale per calcolare la tangente (usando punto precedente) e quindi muoverlo in due componenti: verso il centro e lungo la tangente
        segmento = Segment(radius.c,asteroide)
        puntoora = Point(asteroide.x,asteroide.y)
        asteroide = asteroide.projection(estremo,incremento*mod-correzione/2)
        asteroide = asteroide.projection(radius.c,(accelerazione/150)*(radius.r/segmento.b.distance(segmento.a)))

        d.tick(0.00001)
        asteroide.draw(d)

        puntodopo = Point(asteroide.x,asteroide.y)
        traiettoria = Line(puntoora, puntodopo)
        d.draw(traiettoria)

        #correzione direzione tangente
        if(puntoora.x>puntodopo.x):
            estremo = Point(-100,traiettoria.ordinate(-100))
        else:
            estremo = Point(100,traiettoria.ordinate(100))

        #correzione modulazione
        correzione+=0.001*mod

        mod = (radius.r/segmento.b.distance(segmento.a))
        print(traiettoria.angle())






    #è uscito dall'orbita (da fare)










setup()