##############################
###  DM2_w24  hu_03_setUp  ###
###  _diag  /  2024 10 17  ###
##############################
import rhinoscriptsyntax as rs
import random, time, sys   ###                                              
sys.path.append("P:/WWW/selvo")     ### add path where "DM_lib.py" can be found !!!                                              
import DM_lib as dm        ### reload(dm)    
##############################   

dm.eA()
rs.EnableRedraw(0)
####################################################################################################################################################
#Import Audi Modell

file_path = "G:\\Uni\\Dm2\\Finale\\AudiPoints.txt" ###Opt.###       ###path fuer Punkte von Modell


def import_points_from_file(file_path):                             ###Import von den Punkten
    try:
        file = open(file_path, 'r')                                 ###oeffnet file
        lines = file.readlines()                                    ###lest file
        file.close()                                                ###schliesst file
        
        points = []                                                 ###leere Pointliste von audi
        
        for i, line in enumerate(lines):                            ###fuer jede line in path file
            if i % 1 == 0:                 ###Opt.###              ####wieviele punkte von 47000 genutzt werden. zB i % 10 = jedes 10., daher 4700
                point_data = line.strip().split(',')                ###splittet jede einzelne line. Daher keine ungueltigen lines
                if len(point_data) == 3:                            ###wenn line 3 daten beinhaltet (Koordinaten)
                    try:                                            ###dann versuche
                        x = float(point_data[0])                    ###x = erste data von line
                        y = float(point_data[1])                    ###y = zweite data von line
                        z = float(point_data[2]) -7                 ###z = dritte data von line. -7 weil basismodell bisschen ueber Boden liegt
                        
                        audi_pnts = rs.AddPoint(x, y, z)            ###addpoint fuer jede line in pathfile
                        
                        points.append(audi_pnts)                    ###schliesst audi_pnts an leere points liste an
                    except:
                        print("Invalid line: " + line)              ###wenn eine line nicht funktioniert - fehlermeldung
                else:
                    print("Invalid line: " + line)                  ### wenn line nicht aus 3 daten besteht - fehlermeldung
        return points                                               ### returns points aus der def import...
    except:
        print("Error reading file!")                                ###wenn path file nicht gefunden wird - fehlermeldung

                                                            ###mit Hilfe von ChatGPT
#######################################################################################################################################################
###controls


def controlpoints():                                                ###definition von Punkten welche Platzierung und Rotation kontrollieren
    pnts = []
    ctrl_pnt = rs.AddPoint(0,160,0)                                 ###Kontrollpunkt der Platzierung in der Mitte der Vorderachse - Momentan durch globale Koordinaten definiert
    ctrl_crv_end = rs.AddPoint(0,500,0)                             ###Endkontrollpunkt der Rotation in Fahrtrichtung - Momentan durch globale Koordinaten definiert
    
    pnts.append(ctrl_pnt)                                           ###schliesst Kontrollpunkt Platzierung an leere pnts liste an
    pnts.append(ctrl_crv_end)                                       ###schliesst Kontrollpunkt Rotation an leere pnts liste an
    
    return pnts                                                     ###returns pnts aus def controllpoints



audi0 = import_points_from_file(file_path)                          ###Variable "audi0" fuer NUR Modell des Autos
ctrl_pnts = controlpoints()                                         ###Variable "ctrl_pnts fuer NUR Kontrollpunkte (Vorderachse und Fahrtrichtung
audi = audi0 + ctrl_pnts                                            ###Variable "audi" fuer gesamtes model + Kontrollpunkte

cp = ctrl_pnts[0]                                                   ###Variable cp fuer Kontrollpunkt Platzierung
cc_end = ctrl_pnts[1]                                               ###Kontrollpunkt fuer Vektor der Rotation (Vektor schneidet naechsten Strassenpunkt -> Daher driftet

#######################################################################################################################################################
###path curve

p0 = [ 500 , 0 , 0 ]
p1 = [ 1000 , 0 , 0 ]
p2 = [ 1300 , 300 , 0 ]
p3 = [ 1400 , 600 , 0 ]
p4 = [ 1400 , 1200 , 0 ]
p5 = [ 2000 , 1400 , 200 ]
p6 = [ 2600 , 1400 , 300 ]
p7 = [ 3000 , 2000 , 600 ]  ###Opt.###                              ###Punkte fuer Strasse

divs = 40   ###Opt.###                                              ###Anzahl punkte auf strasse

road = rs.AddCurve( ( p0 , p1 , p2 , p3 , p4 , p5 , p6 , p7 ), 2 )  ###Strassen Curve
roaddiv = rs.DivideCurve( road , divs , True )                      ###Curvedivision Strasse
roadpnt = [rs.AddPoint(pt) for pt in roaddiv]                       ###macht aus division punkte koordinaten

#######################################################################################################################################################
###movement audi


plc = 10               ###Opt.###                                    ###Strassenpunkt an welchen das Auto platziert wird
drift_ang = 3         ###Opt.###                                    ###Winkel von drift (1 = rotiert sich in Richtung des 1. naechsten punkt, 2 = rotiert auf 2. naechsten etc...)

def movement( plc ):                                                     ###Definition fuer Platzierung und Rotation
    if plc < len(roadpnt) -drift_ang:                               ###Sicherung fuer looparound ( wegen drift_ang muss immer die anzahl der punkte von drift_ang nach vorne vorhanden sein - z.B. drift_ang = 2 - es muessen 2 punkte nach vorne vorhanden sein
        movec = rs.VectorCreate( cp , roadpnt[plc] )                ###Movement vector. Vector zwischen momentanen cp und ausgewaehlten Strassenpunkt
        rs.MoveObject( audi , -movec )                              ###Versetzt audi um negativer distanz zu ausgewaehlten Strassenpunkt
        
        
        dir_vec = rs.VectorCreate( roadpnt[ plc + drift_ang ] , roadpnt[ plc ])
                                                                    ###Vector von Platzierungspunkt zu rotationspunkt
        cur_dir_vec = rs.VectorCreate( cc_end , cp )                ###Momentaner Vector von Kontrollpunkt und Rotationskontrollpunkt
        
        rot_ang = rs.VectorAngle( cur_dir_vec , dir_vec )           ###Winkel zwischen momentaner Rotation und gewollter rotation
        rot_ax = [0,0,1]                                            ###Rotationsachse (MOMENTAN NUR AUF Z-ACHSE: STEIGUNGEN NOCH NICHT BERUECKSICHTIGT###############################
        
        rs.RotateObject( audi , cp , -rot_ang , rot_ax )            ###rotiert audi um cp mit negativen rotationsunterschied
        

#movement(plc)

movement (plc)

if 0:
    for plc in range (115):
        move = movement( plc = plc)
        rs.Redraw()                        ###fuehrt Definition fuer Platzierung und rotation aus


##################################################################################
#Camera

if 0:
  
  dm.setCameraTarget(camera=[ 500 , 1700 , 400 ], target=cp, lens=70, rota=0, upVec=0, verbose=0 )