;;;****************************************************************************


(defun mid_coord (p1 p2 / x y dist ang x_mid y_mid p_mid)
  (setq	dist  (distance p1 p2)
	ang   (angle p1 p2)
	x     (* (/ dist 2) (cos ang))
	y     (* (/ dist 2) (sin ang))
	x_mid (+ (car p1) x)
	y_mid (+ (cadr p1) y)
	p_mid (list x_mid y_mid)
  )

)



;;;****************************************************************************
(defun move_point (pn pn_neu pn-1 / ang1 dst1 dst2 wkpt cord)
  (setq	ang1 (- (angle pn-1 pn_neu) (angle pn-1 (mid_coord pn pn_neu)))
	dst1 (distance pn-1 pn_neu)
	dst2 (* dst1 (sin ang1))
	ang2 (- (angle pn-1 (mid_coord pn pn_neu)) (/ pi 2))
	wkpt (polar pn_neu ang2 dst2)
	cord (sqrt
	       (- (* (distance pn pn-1) (distance pn pn-1)) (* dst2 dst2))
	     )
	pnx  (polar wkpt (angle (mid_coord pn pn_neu) pn-1) cord)
  )


)



;;;****************************************************************************


(defun pre_loop
		(liste_a
		 liste_b
		)

  (setq	list_count_a (length liste_a)
	list_count_b (length liste_b)
  )
  (while (= 5 (car (setq pg (grread 't 5 0)))) ;thx to cadmium:)
;;;(while (setq pg (grread t))

    (redraw)
    (setq flag1 1)
    ;;flag für loop-funktion. zeigt an welche liste durch
    ;;new_list ersetzt wird
    (loop liste_a pg list_count_a)
    (setq flag1 nil)
    (loop liste_b pg list_count_b)
  )
(draw_line liste_a liste_b) 
)					;end defun


;;;****************************************************************************

(defun break_list (liste1 pbreak / l_c count)

  (setq	liste1_b (member pbreak liste1)
	l_c	 (- (length liste1) (length liste1_b))
	count	 0
  )
  (repeat (+ 1 l_c)
    (setq liste1_a
		   (cons (nth count liste1) liste1_a)
	  count	   (+ 1 count)
    )
  )
  (setq liste1_a (reverse liste1_a))
  (setq liste1_b (reverse liste1_b))
 
  )
;;;****************************************************************************
(defun break_point ()
  (setvar "osmode" 1)
  (setq pbreak (getpoint "\nPick vertice:"))
  (setvar "osmode" 0)
)
;;;****************************************************************************
(defun init ()
  (setq oldosmode (getvar "Osmode"))
  (setvar "osmode" 0)
)
;;;****************************************************************************
(defun C:pmove (/ pbreak liste1 liste1_a liste1_b list_count flag1 liste liste_a liste_b listea listeb)
  (init)
  (setq list_count (length (lwpoly_show)))
  (break_point)
  (break_list liste1 pbreak)
  (pre_loop liste1_a
	    liste1_b
  )
  ;;(draw_line liste_a liste_b)
  (princ)
)
;;;****************************************************************************
(defun loop (liste	  pg	       list_count   /
	     new_list	  new_list_count	    list_repeat
	     pnx
	    )
;;;****************************************************************************
;;;zuerst müssen die in jeder while-schleife generierten listen
;;;(new_list) und die Zählvariable (new_list_count) auf nil gesetzt
;;;werden. außerdem muß list_count bei jedem Schleifendurchlauf auf
;;;list_repeat übergeben werden (wird bei Schleifendurchlauf ja runtergezählt).
;;;****************************************************************************
  (setq
    new_list nil
    new_list_count
     nil
    list_repeat
     list_count
  )
					;(redraw)
  (setq	pnx	 (cadr pg)
	new_list (cons pnx new_list)
  )
;;;****************************************************************************
  (repeat (- list_repeat 1)
    (move_point
      (nth (- list_repeat 1) liste)
      pnx
      (nth (- list_repeat 2) liste)
    )
;;;move_point-funktion. weist pnx neuen wert zu. übergabe von pn und
;;;pn-1 aus liste1.

    (setq list_repeat (- list_repeat 1)
	  new_list    (cons pnx new_list)
    )
  )					;end repeat
;;;****************************************************************************
  (if flag1
    (setq liste_a new_list)
    (setq liste_b new_list)
  )
;;;liste1 (ursprüngliche punktliste) wird
;;;durch neugenerierte liste (new_list)
;;;ersetzt!
  (setq	new_list_count (length new_list)
	new_list       (reverse new_list)
  )

;;;****************************************************************************
;;;jetzt durch new_list iterieren und punkte mit grdraw verbinden:
  (repeat (- new_list_count 1)
    (grdraw
      (nth (- new_list_count 1) new_list)
      (nth (- new_list_count 2) new_list)
      -1
    )
    (setq new_list_count (- new_list_count 1))
  )
)

;;;****************************************************************************
(defun draw_line (listea listeb / ct p1 )
  (setq	draw_list (append listea  (reverse listeb));;;hier ein reverse???
	ct	  0
  )
;;;  (if (or(= (length listea) 1)
;;;	 (= (length listeb)1)
;;;	 )
;;;    (setq draw_list (cdr (reverse draw_list)))
;;;    )
  
 (setq draw_list(removeDups draw_list))
  
    (command "_pline")
    (while (<= ct
	       (-(length draw_list)1)
	       )
      (setq p1 (nth ct draw_list))
      (setq ct (1+ ct))
      (command p1)
      ;;;(command "")
      )
    (command "")


 (entdel pobj)
)

;;;****************************************************************************
(defun LWPOLY_SHOW (/ el )
  (setq el (entget (setq pobj(car (entsel)))))
  (while (setq EL (member (assoc 10 EL) EL))
    (setq
      liste1 (cons (reverse (cons 0.0 (reverse (cdr (assoc 10 EL)))))
		   liste1
	     )
    )
    (setq EL (cdr EL))
  )
;;;  (setq check-list (reverse liste1))
  (setq liste1 (reverse liste1))
  (removedups liste1)
  
)
;;;----------------------------------------------------------------------------



(defun removeDups (#liste / cleanListe);kthx an cad.de,weiß jetzt nicht wer's geschrieben hat ;-)
  (foreach eintrag #liste
    (if (not(member eintrag cleanListe))
      (setq cleanListe (cons eintrag cleanListe))
    )
  )
  ;** Rückgabe, wenn's auf Reihenfolge ankommt:
  (reverse cleanListe);** ansonsten reicht: cleanListe
)