Is lisp Calculating?

Hi everyone,

I'm only starting to learn about Lisp programing, and really don't know a lot about that...yet... so here is a problem..

I would like to create a program, which could draw several lines horizontaly. In my imagination it should work like this:

In AutoCad I show a square, and the program asks me how many lines I want to be drawn. When I give her a number, she divides total square length by my given number, and then draws the lines ( the length of a line program also gets from the square).

The question would be:

Can AutoCad calculate? (In my case divide) And maybe someone already has something similar?

Hi,

This can definitely be done using Lisp. I use VBA for AutoCad customizations, but may be someone here will help you with this lisp. Writing it should not take long.

You mean something like this?

(defun c:HFillRect (/ pt1 pt2 div h v vdiv p1 p2)
 (if (and (setq pt1 (getpoint "\nGet start point of rectancgle: "))
          (setq pt2 (getcorner pt1 "\nGet 2nd point of rectangle: "))
          (setq div (getint "\nHow many lines: "))
     )
   (progn
     (setq p1 (list (min (car pt1) (car pt2)) (min (cadr pt1) (cadr pt2)) (min (caddr pt1) (caddr pt2))) ;Left-bottom
           p2 (list (max (car pt1) (car pt2)) (max (cadr pt1) (cadr pt2)) (max (caddr pt1) (caddr pt2))) ;Right-top
           h  (- (car p2) (car p1)) ;Horizontal length
           v  (- (cadr p2) (cadr p1));Vertical length
           vdiv (/ v div) ;Vertical division length
           pt1 p1 ;Start point of line
           pt2 (list (car p2) (cadr p1) (caddr p2)) ;Endpoint of line
     )
     (while (< (cadr pt1) (cadr p2))
       (command "._LINE" "_None" pt1 "_None" pt2 "")
       (setq pt1 (list (car pt1) (+ (cadr pt1) vdiv) (caddr pt1))
             pt2 (list (car pt2) (+ (cadr pt2) vdiv) (caddr pt2))
       )
     )
   )
 )
 (princ)
)

Or perhaps something like this?

(defun c:hlines ( / p1 p2 h n v )
 (if
   (and
     (setq p1 (getpoint "\nSpecify First Corner: "))
     (setq p2 (getcorner "\nSpecify Opposite Corner: " p1))
     (progn (initget 6) (setq n (getint "\nSpecify Number of Lines: ")))
   )
   (progn
     (setq h (- (car p2) (car p1))
           v (if (= 1 n) 0. (/ (- (cadr p2) (cadr p1)) (1- n)))
     )
     (repeat n
       (entmakex
         (list
           (cons 0 "LINE")
           (cons 10 (trans p1 1 0))
           (cons 11 (trans (list (+ (car p1) h) (cadr p1) (caddr p1)) 1 0))
         )
       )
       (setq p1 (list (car p1) (+ v (cadr p1)) (caddr p1)))
     )
   )
 )
 (princ)
)

Or, depending on the behaviour you are looking for:

(defun c:hlines ( / p1 p2 h n v )
 (if
   (and
     (setq p1 (getpoint "\nSpecify First Corner: "))
     (setq p2 (getcorner "\nSpecify Opposite Corner: " p1))
     (progn (initget 6) (setq n (getint "\nSpecify Number of Lines: ")))
   )
   (progn
     (setq h (- (car p2) (car p1))
           v (/ (- (cadr p2) (cadr p1)) (1+ n))
     )
     (repeat n (setq p1 (list (car p1) (+ v (cadr p1)) (caddr p1)))
       (entmakex
         (list
           (cons 0 "LINE")
           (cons 10 (trans p1 1 0))
           (cons 11 (trans (list (+ (car p1) h) (cadr p1) (caddr p1)) 1 0))
         )
       )
     )
   )
 )
 (princ)
)

This thread reminded me of a similar thread here.

well yeah,

you made all the program, by the time i figured out how to start it

just only one thing, i explained wrong is that the lines has to be vertical, but the distance divided horizontaly...

I've attached i picture to this post, to explain more understandable...here is some things about this programs I want to do:

1. First and last lines always are blue.

2.All the lines belong to layer - profile

3.the Squere block on the lines belong to layer kons1

4.The circle block on the lines belong to layer kons2

5. distance between all the circle and squere block never is bigger then 70 (all the gaps between ar equal),if needed, aditional circle blocks can be added to the line.

6. Distance from the line start/end till the blocks are always 10.

So if someone wants this challange, and want's to help me out, pls feel free... becouse as I see, for me it would take ages to make a program like this, and here first post came after several minutes...

[ATTACH]28609[/ATTACH][ATTACH]28610[/ATTACH]... In other case thnx, I will share my lisp whit you anyway later, just to know what you think about it

More fun with grread...

A fun program to write, but certainly not practical:

Dynamic Horizontal:

([color=BLUE]defun[/color] c:hlines ( [color=BLUE]/[/color] *error* g1 g2 gr h l ms p p1 p2 v )
 [color=GREEN];; Lee Mac 2011[/color]
 ([color=BLUE]defun[/color] *error* ( m ) ([color=BLUE]redraw[/color]) ([color=BLUE]princ[/color]))
 ([color=BLUE]or[/color] *n ([color=BLUE]setq[/color] *n 3))
 
 ([color=BLUE]if[/color] ([color=BLUE]setq[/color] p1 ([color=BLUE]getpoint[/color] [color=MAROON]"\nSpecify First Corner: "[/color]))
   ([color=BLUE]progn[/color]
     ([color=BLUE]setq[/color] ms ([color=BLUE]princ[/color] [color=MAROON]"\nSpecify Opposite Corner [+/-]: "[/color]))
     ([color=BLUE]while[/color]
       ([color=BLUE]progn[/color] ([color=BLUE]setq[/color] gr ([color=BLUE]grread[/color] [color=BLUE]t[/color] 15 0) g1 ([color=BLUE]car[/color] gr) g2 ([color=BLUE]cadr[/color] gr))
         ([color=BLUE]cond[/color]
           ( ([color=BLUE]=[/color] 5 g1)([color=BLUE]redraw[/color])
             ([color=BLUE]setq[/color] h ([color=BLUE]-[/color] ([color=BLUE]car[/color] g2) ([color=BLUE]car[/color] p1))
                   v ([color=BLUE]/[/color] ([color=BLUE]-[/color] ([color=BLUE]cadr[/color] g2) ([color=BLUE]cadr[/color] p1)) ([color=BLUE]1+[/color] *n))
                   p p1
             )
             ([color=BLUE]repeat[/color] *n
               ([color=BLUE]setq[/color] p ([color=BLUE]list[/color] ([color=BLUE]car[/color] p) ([color=BLUE]+[/color] v ([color=BLUE]cadr[/color] p)) ([color=BLUE]caddr[/color] p)))
               ([color=BLUE]grdraw[/color] p ([color=BLUE]list[/color] ([color=BLUE]+[/color] ([color=BLUE]car[/color] p) h) ([color=BLUE]cadr[/color] p) ([color=BLUE]caddr[/color] p)) -1)
             )
             ([color=BLUE]setq[/color] l
               ([color=BLUE]list[/color]
                 p1 ([color=BLUE]list[/color] ([color=BLUE]+[/color] ([color=BLUE]car[/color] p1) h) ([color=BLUE]cadr[/color] p1) ([color=BLUE]caddr[/color] p1))
                 g2 ([color=BLUE]list[/color] ([color=BLUE]car[/color] p) ([color=BLUE]+[/color] v ([color=BLUE]cadr[/color] p)) ([color=BLUE]caddr[/color] p))
               )
             )
             ([color=BLUE]mapcar[/color] '([color=BLUE]lambda[/color] ( a b ) ([color=BLUE]grdraw[/color] a b 1 -1)) l ([color=BLUE]append[/color] ([color=BLUE]cdr[/color] l) ([color=BLUE]list[/color] ([color=BLUE]car[/color] l))))
           )
           ( ([color=BLUE]=[/color] 2 g1)
             ([color=BLUE]cond[/color]
               ( ([color=BLUE]member[/color] g2 '(45 95))
                 ([color=BLUE]if[/color] ([color=BLUE]=[/color] 1 *n)
                   ([color=BLUE]princ[/color] ([color=BLUE]strcat[/color] [color=MAROON]"\n--> Minimum Number of Lines Reached."[/color] ms))
                   ([color=BLUE]setq[/color] *n ([color=BLUE]1-[/color] *n))
                 )
               )
               ( ([color=BLUE]member[/color] g2 '(43 61))
                 ([color=BLUE]setq[/color] *n ([color=BLUE]1+[/color] *n))
               )
             )
           )
           ( ([color=BLUE]=[/color] 3 g1)
             ([color=BLUE]setq[/color] h ([color=BLUE]-[/color] ([color=BLUE]car[/color] g2) ([color=BLUE]car[/color] p1))
                   v ([color=BLUE]/[/color] ([color=BLUE]-[/color] ([color=BLUE]cadr[/color] g2) ([color=BLUE]cadr[/color] p1)) ([color=BLUE]1+[/color] *n))
             )
             ([color=BLUE]repeat[/color] *n ([color=BLUE]setq[/color] p1 ([color=BLUE]list[/color] ([color=BLUE]car[/color] p1) ([color=BLUE]+[/color] v ([color=BLUE]cadr[/color] p1)) ([color=BLUE]caddr[/color] p1)))
               ([color=BLUE]entmakex[/color]
                 ([color=BLUE]list[/color]
                   ([color=BLUE]cons[/color] 0 [color=MAROON]"LINE"[/color])
                   ([color=BLUE]cons[/color] 10 ([color=BLUE]trans[/color] p1 1 0))
                   ([color=BLUE]cons[/color] 11 ([color=BLUE]trans[/color] ([color=BLUE]list[/color] ([color=BLUE]+[/color] ([color=BLUE]car[/color] p1) h) ([color=BLUE]cadr[/color] p1) ([color=BLUE]caddr[/color] p1)) 1 0))
                 )
               )
             )
             [color=BLUE]nil[/color]
           )
         )
       )
     )
   )
 )
 ([color=BLUE]redraw[/color]) ([color=BLUE]princ[/color])
)

Dynamic Vertical:

([color=BLUE]defun[/color] c:vlines ( [color=BLUE]/[/color] *error* g1 g2 gr h l ms p p1 p2 v )
 [color=GREEN];; Lee Mac 2011[/color]
 ([color=BLUE]defun[/color] *error* ( m ) ([color=BLUE]redraw[/color]) ([color=BLUE]princ[/color]))
 ([color=BLUE]or[/color] *n ([color=BLUE]setq[/color] *n 3))
 
 ([color=BLUE]if[/color] ([color=BLUE]setq[/color] p1 ([color=BLUE]getpoint[/color] [color=MAROON]"\nSpecify First Corner: "[/color]))
   ([color=BLUE]progn[/color]
     ([color=BLUE]setq[/color] ms ([color=BLUE]princ[/color] [color=MAROON]"\nSpecify Opposite Corner [+/-]: "[/color]))
     ([color=BLUE]while[/color]
       ([color=BLUE]progn[/color] ([color=BLUE]setq[/color] gr ([color=BLUE]grread[/color] [color=BLUE]t[/color] 15 0) g1 ([color=BLUE]car[/color] gr) g2 ([color=BLUE]cadr[/color] gr))
         ([color=BLUE]cond[/color]
           ( ([color=BLUE]=[/color] 5 g1)([color=BLUE]redraw[/color])
             ([color=BLUE]setq[/color] h ([color=BLUE]/[/color] ([color=BLUE]-[/color] ([color=BLUE]car[/color] g2) ([color=BLUE]car[/color] p1)) ([color=BLUE]1+[/color] *n))
                   v ([color=BLUE]-[/color] ([color=BLUE]cadr[/color] g2) ([color=BLUE]cadr[/color] p1))
                   p p1
             )
             ([color=BLUE]repeat[/color] *n
               ([color=BLUE]setq[/color] p ([color=BLUE]list[/color] ([color=BLUE]+[/color] h ([color=BLUE]car[/color] p)) ([color=BLUE]cadr[/color] p) ([color=BLUE]caddr[/color] p)))
               ([color=BLUE]grdraw[/color] p ([color=BLUE]list[/color] ([color=BLUE]car[/color] p) ([color=BLUE]+[/color] v ([color=BLUE]cadr[/color] p)) ([color=BLUE]caddr[/color] p)) -1)
             )
             ([color=BLUE]setq[/color] l
               ([color=BLUE]list[/color]
                 p1 ([color=BLUE]list[/color] ([color=BLUE]car[/color] p1) ([color=BLUE]+[/color] v ([color=BLUE]cadr[/color] p1)) ([color=BLUE]caddr[/color] p1))
                 g2 ([color=BLUE]list[/color] ([color=BLUE]+[/color] h ([color=BLUE]car[/color] p)) ([color=BLUE]cadr[/color] p) ([color=BLUE]caddr[/color] p))
               )
             )
             ([color=BLUE]mapcar[/color] '([color=BLUE]lambda[/color] ( a b ) ([color=BLUE]grdraw[/color] a b 1 -1)) l ([color=BLUE]append[/color] ([color=BLUE]cdr[/color] l) ([color=BLUE]list[/color] ([color=BLUE]car[/color] l))))
           )
           ( ([color=BLUE]=[/color] 2 g1)
             ([color=BLUE]cond[/color]
               ( ([color=BLUE]member[/color] g2 '(45 95))
                 ([color=BLUE]if[/color] ([color=BLUE]=[/color] 1 *n)
                   ([color=BLUE]princ[/color] ([color=BLUE]strcat[/color] [color=MAROON]"\n--> Minimum Number of Lines Reached."[/color] ms))
                   ([color=BLUE]setq[/color] *n ([color=BLUE]1-[/color] *n))
                 )
               )
               ( ([color=BLUE]member[/color] g2 '(43 61))
                 ([color=BLUE]setq[/color] *n ([color=BLUE]1+[/color] *n))
               )
             )
           )
           ( ([color=BLUE]=[/color] 3 g1)
             ([color=BLUE]setq[/color] h ([color=BLUE]/[/color] ([color=BLUE]-[/color] ([color=BLUE]car[/color] g2) ([color=BLUE]car[/color] p1)) ([color=BLUE]1+[/color] *n))
                   v ([color=BLUE]-[/color] ([color=BLUE]cadr[/color] g2) ([color=BLUE]cadr[/color] p1))
             )
             ([color=BLUE]repeat[/color] *n ([color=BLUE]setq[/color] p1 ([color=BLUE]list[/color] ([color=BLUE]+[/color] h ([color=BLUE]car[/color] p1)) ([color=BLUE]cadr[/color] p1) ([color=BLUE]caddr[/color] p1)))
               ([color=BLUE]entmakex[/color]
                 ([color=BLUE]list[/color]
                   ([color=BLUE]cons[/color] 0 [color=MAROON]"LINE"[/color])
                   ([color=BLUE]cons[/color] 10 ([color=BLUE]trans[/color] p1 1 0))
                   ([color=BLUE]cons[/color] 11 ([color=BLUE]trans[/color] ([color=BLUE]list[/color] ([color=BLUE]car[/color] p1) ([color=BLUE]+[/color] v ([color=BLUE]cadr[/color] p1)) ([color=BLUE]caddr[/color] p1)) 1 0))
                 )
               )
             )
             [color=BLUE]nil[/color]
           )
         )
       )
     )
   )
 )
 ([color=BLUE]redraw[/color]) ([color=BLUE]princ[/color])
)

Combining the two...

(defun c:hvlines ( / *error* g1 g2 gr h l ms p p1 p2 v )
 ;; Lee Mac 2011
 (defun *error* ( m ) (redraw) (princ))
 (or *n (setq *n 3))
 
 (if (setq p1 (getpoint "\nSpecify First Corner: "))
   (progn
     (setq ms (princ "\nSpecify Opposite Corner [TAB/+/-]: "))
     (while
       (progn (setq gr (grread t 15 0) g1 (car gr) g2 (cadr gr))
         (cond
           ( (= 5 g1)(redraw)
             (if *v
               (progn
                 (setq h (/ (- (car g2) (car p1)) (1+ *n))
                       v (- (cadr g2) (cadr p1))
                       p p1
                 )
                 (repeat *n
                   (setq p (list (+ h (car p)) (cadr p) (caddr p)))
                   (grdraw p (list (car p) (+ v (cadr p)) (caddr p)) -1)
                 )
                 (setq l
                   (list
                     p1 (list (car p1) (+ v (cadr p1)) (caddr p1))
                     g2 (list (+ h (car p)) (cadr p) (caddr p))
                   )
                 )
               )
               (progn
                 (setq h (- (car g2) (car p1))
                       v (/ (- (cadr g2) (cadr p1)) (1+ *n))
                       p p1
                 )
                 (repeat *n
                   (setq p (list (car p) (+ v (cadr p)) (caddr p)))
                   (grdraw p (list (+ (car p) h) (cadr p) (caddr p)) -1)
                 )
                 (setq l
                   (list
                     p1 (list (+ (car p1) h) (cadr p1) (caddr p1))
                     g2 (list (car p) (+ v (cadr p)) (caddr p))
                   )
                 )
               )
             )                  
             (mapcar '(lambda ( a b ) (grdraw a b 1 -1)) l (append (cdr l) (list (car l))))
           )
           ( (= 2 g1)
             (cond
               ( (member g2 '(45 95))
                 (if (= 1 *n)
                   (princ (strcat "\n--> Minimum Number of Lines Reached." ms))
                   (setq *n (1- *n))
                 )
               )
               ( (member g2 '(43 61))
                 (setq *n (1+ *n))
               )
               ( (= 9 g2)
                 (setq *v (not *v)) t
               )
             )
           )
           ( (= 3 g1)
             (if *v
               (progn
                 (setq h (/ (- (car g2) (car p1)) (1+ *n))
                       v (- (cadr g2) (cadr p1))
                 )
                 (repeat *n (setq p1 (list (+ h (car p1)) (cadr p1) (caddr p1)))
                   (entmakex
                     (list
                       (cons 0 "LINE")
                       (cons 10 (trans p1 1 0))
                       (cons 11 (trans (list (car p1) (+ v (cadr p1)) (caddr p1)) 1 0))
                     )
                   )
                 )
               )
               (progn
                 (setq h (- (car g2) (car p1))
                       v (/ (- (cadr g2) (cadr p1)) (1+ *n))
                 )
                 (repeat *n (setq p1 (list (car p1) (+ v (cadr p1)) (caddr p1)))
                   (entmakex
                     (list
                       (cons 0 "LINE")
                       (cons 10 (trans p1 1 0))
                       (cons 11 (trans (list (+ (car p1) h) (cadr p1) (caddr p1)) 1 0))
                     )
                   )
                 )
               )
             )
             nil
           )
         )
       )
     )
   )
 )
 (redraw) (princ)
)

A quick modification of my earlier code to create vertical lines:

(defun c:vlines ( / p1 p2 h n v )
 (if
   (and
     (setq p1 (getpoint "\nSpecify First Corner: "))
     (setq p2 (getcorner "\nSpecify Opposite Corner: " p1))
     (progn (initget 6) (setq n (getint "\nSpecify Number of Lines: ")))
   )
   (progn
     (setq h (if (= 1 n) 0. (/ (- (car p2) (car p1)) (1- n)))
           v (- (cadr p2) (cadr p1))
     )
     (repeat n
       (entmakex
         (list
           (cons 0 "LINE")
           (cons 10 (trans p1 1 0))
           (cons 11 (trans (list (car p1) (+ (cadr p1) v) (caddr p1)) 1 0))
         )
       )
       (setq p1 (list (+ h (car p1)) (cadr p1) (caddr p1)))
     )
   )
 )
 (princ)
)

rekoj i want to see that lisp with lines and blocks please its basicly why i wanted to learn lisp but these tigers will discourage anyone:)

Lee your fun with 3 lines is practical I will ask straight forward will you do some modifications to your program so it right what i need?

it will involve some calculations in line spacing within a rectangle

than calc. on spacing of blocks on line

insreting my blocks

maybe dispalying rectangle's dimension

putting this on layers that if dont exist create

that deleting just a rectangel

i got untill here

(defun c:xxx (/ pt1 pt2 pt3 pt4 bay)
 (setq pt1 (getpoint "/nTop:"))
(setq pt2 (getcorner "/nBottom" pt1))
      (setq pt3 (list (nth 0 pt2)(nth 1 pt1)))
       	(setq pt4 (list (nth 0 pt1)(nth 1 pt2)))
      (command ".rectang" pt1 pt2)

(setq bay (command ".dist" (pt1 pt3))-cant get a value
 (print "bay")
 Princ
 )

Start with Lees code!

ok blue lines v's red the repeat n is number of bars so the red's are n-2

This is not tested just cut and pasted. expects layers red & blue to exist.

(defun c:vlines ( / p1 p2 h n v )
 (if
   (and
     (setq p1 (getpoint "\nSpecify First Corner: "))
     (setq p2 (getcorner "\nSpecify Opposite Corner: " p1))
     (progn (initget 6) (setq [color=red]numline[/color] (getint "\nSpecify Number of Lines: ")))

   )
   (progn
[color=red](setq n (- numline 2))[/color]
     (setq h (if (= 1 n) 0. (/ (- (car p2) (car p1)) (1- n)))
           v (- (cadr p2) (cadr p1))
     )
[color=darkred][/color] 
[color=darkred]       (entmakex
         (list
           (cons 0 "LINE")[/color]
[color=darkred]            (cons 8 "blue")
           (cons 10 (trans p1 1 0))
           (cons 11 (trans (list (car p1) (+ (cadr p1) v) (caddr p1)) 1 0))
         )
       )
       (setq p1 (list (+ h (car p1)) (cadr p1) (caddr p1)))
     )
[/color]      (repeat n
       (entmakex
         (list
           (cons 0 "LINE")
[color=red](cons 8 "Red")[/color]
           (cons 10 (trans p1 1 0))
           (cons 11 (trans (list (car p1) (+ (cadr p1) v) (caddr p1)) 1 0))
         )
       )
       (setq p1 (list (+ h (car p1)) (cadr p1) (caddr p1)))
[color=#8b0000]       (entmakex
         (list
           (cons 0 "LINE")
(cons 8 "BLUE")            [/color]
[color=#8b0000](cons 10 (trans p1 1 0))
           (cons 11 (trans (list (car p1) (+ (cadr p1) v) (caddr p1)) 1 0))
         )
       )
       (setq p1 (list (+ h (car p1)) (cadr p1) (caddr p1)))
     )[/color]

     )
   )
 )
 (princ)
)

More fun with grread...

 

A fun program to write, but certainly not practical:

 

[ATTACH]28613[/ATTACH]

 

([color=BLUE]defun[/color] c:hlines ( [color=BLUE]/[/color] *error* g1 g2 gr h l ms p p1 p2 v )
 [color=GREEN];; Lee Mac 2011[/color]
 ([color=BLUE]defun[/color] *error* ( m ) ([color=BLUE]redraw[/color]) ([color=BLUE]princ[/color]))
 ([color=BLUE]or[/color] *n ([color=BLUE]setq[/color] *n 3))
 
 ([color=BLUE]if[/color] ([color=BLUE]setq[/color] p1 ([color=BLUE]getpoint[/color] [color=MAROON]"\nSpecify First Corner: "[/color]))
   ([color=BLUE]progn[/color]
     ([color=BLUE]setq[/color] ms ([color=BLUE]princ[/color] [color=MAROON]"\nSpecify Opposite Corner [+/-]: "[/color]))
     ([color=BLUE]while[/color]
       ([color=BLUE]progn[/color] ([color=BLUE]setq[/color] gr ([color=BLUE]grread[/color] [color=BLUE]t[/color] 15 0) g1 ([color=BLUE]car[/color] gr) g2 ([color=BLUE]cadr[/color] gr))
         ([color=BLUE]cond[/color]
           ( ([color=BLUE]=[/color] 5 g1)([color=BLUE]redraw[/color])
             ([color=BLUE]setq[/color] h ([color=BLUE]-[/color] ([color=BLUE]car[/color] g2) ([color=BLUE]car[/color] p1))
                   v ([color=BLUE]/[/color] ([color=BLUE]-[/color] ([color=BLUE]cadr[/color] g2) ([color=BLUE]cadr[/color] p1)) ([color=BLUE]1+[/color] *n))
                   p p1
             )
             ([color=BLUE]repeat[/color] *n
               ([color=BLUE]setq[/color] p ([color=BLUE]list[/color] ([color=BLUE]car[/color] p) ([color=BLUE]+[/color] v ([color=BLUE]cadr[/color] p)) ([color=BLUE]caddr[/color] p)))
               ([color=BLUE]grdraw[/color] p ([color=BLUE]list[/color] ([color=BLUE]+[/color] ([color=BLUE]car[/color] p) h) ([color=BLUE]cadr[/color] p) ([color=BLUE]caddr[/color] p)) -1)
             )
             ([color=BLUE]setq[/color] l
               ([color=BLUE]list[/color]
                 p1 ([color=BLUE]list[/color] ([color=BLUE]+[/color] ([color=BLUE]car[/color] p1) h) ([color=BLUE]cadr[/color] p1) ([color=BLUE]caddr[/color] p1))
                 g2 ([color=BLUE]list[/color] ([color=BLUE]car[/color] p) ([color=BLUE]+[/color] v ([color=BLUE]cadr[/color] p)) ([color=BLUE]caddr[/color] p))
               )
             )
             ([color=BLUE]mapcar[/color] '([color=BLUE]lambda[/color] ( a b ) ([color=BLUE]grdraw[/color] a b 1 -1)) l ([color=BLUE]append[/color] ([color=BLUE]cdr[/color] l) ([color=BLUE]list[/color] ([color=BLUE]car[/color] l))))
           )
           ( ([color=BLUE]=[/color] 2 g1)
             ([color=BLUE]cond[/color]
               ( ([color=BLUE]member[/color] g2 '(45 95))
                 ([color=BLUE]if[/color] ([color=BLUE]=[/color] 1 *n)
                   ([color=BLUE]princ[/color] ([color=BLUE]strcat[/color] [color=MAROON]"\n--> Minimum Number of Lines Reached."[/color] ms))
                   ([color=BLUE]setq[/color] *n ([color=BLUE]1-[/color] *n))
                 )
               )
               ( ([color=BLUE]member[/color] g2 '(43 61))
                 ([color=BLUE]setq[/color] *n ([color=BLUE]1+[/color] *n))
               )
             )
           )
           ( ([color=BLUE]=[/color] 3 g1)
             ([color=BLUE]setq[/color] h ([color=BLUE]-[/color] ([color=BLUE]car[/color] g2) ([color=BLUE]car[/color] p1))
                   v ([color=BLUE]/[/color] ([color=BLUE]-[/color] ([color=BLUE]cadr[/color] g2) ([color=BLUE]cadr[/color] p1)) ([color=BLUE]1+[/color] *n))
             )
             ([color=BLUE]repeat[/color] *n ([color=BLUE]setq[/color] p1 ([color=BLUE]list[/color] ([color=BLUE]car[/color] p1) ([color=BLUE]+[/color] v ([color=BLUE]cadr[/color] p1)) ([color=BLUE]caddr[/color] p1)))
               ([color=BLUE]entmakex[/color]
                 ([color=BLUE]list[/color]
                   ([color=BLUE]cons[/color] 0 [color=MAROON]"LINE"[/color])
                   ([color=BLUE]cons[/color] 10 ([color=BLUE]trans[/color] p1 1 0))
                   ([color=BLUE]cons[/color] 11 ([color=BLUE]trans[/color] ([color=BLUE]list[/color] ([color=BLUE]+[/color] ([color=BLUE]car[/color] p1) h) ([color=BLUE]cadr[/color] p1) ([color=BLUE]caddr[/color] p1)) 1 0))
                 )
               )
             )
             [color=BLUE]nil[/color]
           )
         )
       )
     )
   )
 )
 ([color=BLUE]redraw[/color]) ([color=BLUE]princ[/color])
)

Hi & Thanks Lee. Please tell me what codes decided which [+/-] to do ?

P/S :

Oh, i found it belong g2.

Thanks again

I like the thing Lee Mac did whit [+/-], try to learn this, and use it for my Lisp (talking about vertical line case). But now, can anyone help me out to figure, how to make only two lines from the sides - blue, and all the other, in the middle - red...?

but these tigers will discourage anyone

That's certainly not my intention - I hope others can learn from the examples I post, not be discouraged by them.

Qonfire, please use CODE TAGS!!!

Rekoj look at my last post I did what you asked.

BIGAL somehow it doesn't work for me... Now mater how many amount of lines I enter, it always gets me one line without any color.. Is it just for me like this?

A quick modification of my code in post #8:

(defun c:vlines ( / p1 p2 h i n v )
 (if
   (and
     (setq p1 (getpoint "\nSpecify First Corner: "))
     (setq p2 (getcorner "\nSpecify Opposite Corner: " p1))
     (progn (initget 6) (setq n (getint "\nSpecify Number of Lines: ")))
   )
   (progn
     (setq h (if (= 1 n) 0. (/ (- (car p2) (car p1)) (1- n)))
           v (- (cadr p2) (cadr p1))
           i 1
     )
     (repeat n
       (entmakex
         (list
           (cons 0 "LINE")
           (cons 8 "Profile")
           (cons 62 (if (or (= 1 i) (= n i)) 5 1))
           (cons 10 (trans p1 1 0))
           (cons 11 (trans (list (car p1) (+ (cadr p1) v) (caddr p1)) 1 0))
         )
       )
       (setq p1 (list (+ h (car p1)) (cadr p1) (caddr p1)) i (1+ i))
     )
   )
 )
 (princ)
)

I do admit I didn't test it but what I am saying is you need to subtract from the number of segments 2 you then draw 1 line on one layer "Profile1" you then draw n-2 lines on layer "profile2" you then draw the last line on layer "profile 1.

What I was getting at is you need to change Lee's code to do 3 entmakex in the routine, put 1 before the (repeat n and one after the end of the repeat function.

Lee a suggestion to help the problem for rekoj please note code is not tested as no autocad at moment need to check brackets.

For rekoj using the defun "makeline" makes it easier to repeat a simple function multiple times but with only one variable change in this case the layer name more defuns can be added to place the circle blocks etc also and have different ones at different locations. using this you can create a multi lines question rather than 1 row at a time.

(defun c:vlines2 ( / p1 p2 h i n v )

(defun makeline (layans)
(entmakex
         (list
           (cons 0 "LINE")
           (cons 8 layans)
           (cons 62 (if (or (= 1 i) (= n i)) 5 1))
           (cons 10 (trans p1 1 0))
           (cons 11 (trans (list (car p1) (+ (cadr p1) v) (caddr p1)) 1 0))
         )
       )
       (setq p1 (list (+ h (car p1)) (cadr p1) (caddr p1)) i (1+ i))
     )


 (if
   (and
     (setq p1 (getpoint "\nSpecify First Corner: "))
     (setq p2 (getcorner "\nSpecify Opposite Corner: " p1))
     (progn (initget 6) (setq n (getint "\nSpecify Number of Lines: ")))
   )
   (progn
     (setq h (if (= 1 n) 0. (/ (- (car p2) (car p1)) (1- n)))
           v (- (cadr p2) (cadr p1))
           i 1
     )
(setq layans "profile1")   ; 1st line
(makeline layans)

(setq layans "profile2")  ;n-2 lines
(repeat n
(makeline layans)   
)

(setq layans "profile1")  ; last line
(makeline layans)
)
) 

 (princ)
)

Using a counter (as in my code in post #17) there should be no need to have multiple repeat loops.

Also, when I enter the amount of lines in BIGALS's lisp, they are drawn not in the middle of the blue ones, but outcide.

By the way, Le Mac, maybe there is any chance you could explain step by step meaning of functions you made in post #7. Already second day I'm trying to explore that lisp and to change the lines direction from horisontal to vertical.. But I'm really getting lost when trying to figure what anything means.. When I change it as I think it should be, the program does noncenses or doesn't work at all...