;;; BUILDINGPLAN.

LSP - Automatic Building Plan Generator for AutoCAD

;;; Creates walls, doors, windows, and room labels based on user input

(defun c:BUILDINGPLAN (/ outerPt width depth wallThk numRooms roomList

originPt extWalls intWalls doorWidth windowWidth

windowHeight doorList windowList)

;; Initialize variables

(setvar "CMDECHO" 0)

(command "_.UNDO" "_BEGIN")

;; Create a new layer for building elements

(if (not (tblsearch "LAYER" "A-WALLS"))

(command "_.LAYER" "_M" "A-WALLS" "_C" "7" "" ""))

(if (not (tblsearch "LAYER" "A-DOORS"))

(command "_.LAYER" "_M" "A-DOORS" "_C" "2" "" ""))

(if (not (tblsearch "LAYER" "A-WINDOWS"))

(command "_.LAYER" "_M" "A-WINDOWS" "_C" "4" "" ""))

(if (not (tblsearch "LAYER" "A-TEXT"))

(command "_.LAYER" "_M" "A-TEXT" "_C" "1" "" ""))

;; Get building parameters from user

(setq outerPt (getpoint "\nSpecify lower-left corner of building: "))

(setq width (getdist outerPt "\nEnter building width: "))

(setq depth (getdist outerPt "\nEnter building depth: "))

(setq wallThk (getdist "\nEnter wall thickness: "))

(setq numRooms (getint "\nEnter number of rooms (2-10): "))

 ;; Set standard dimensions

(setq doorWidth 0.9) ; Standard door width = 900mm

(setq windowWidth 1.2) ; Standard window width = 1200mm

(setq windowHeight 1.2) ; Standard window height from floor

;; Draw outer walls

(command "_.LAYER" "_S" "A-WALLS" "")

(setq extWalls (entlast))

(command "_.RECTANG" outerPt (list (+ (car outerPt) width) (+ (cadr

outerPt) depth)))

(command "_.OFFSET" wallThk (entlast) (list (+ (car outerPt) (/ width 2.0))

(+ (cadr outerPt) (/ depth 2.0))) "")

(command "_.HATCH" "SOLID" "" "" "_S" (entlast) "" "")

;; Generate room division walls based on number of rooms

(setq roomList (generateRooms outerPt width depth wallThk numRooms))

;; Place doors in walls

(setq doorList (placeDoors roomList doorWidth wallThk))

;; Place windows in external walls

(setq windowList (placeWindows outerPt width depth wallThk windowWidth

windowHeight))

;; Label rooms

(labelRooms roomList)
 ;; Cleanup and finalize

(command "_.ZOOM" "_E")

(command "_.UNDO" "_END")

(setvar "CMDECHO" 1)

(princ (strcat "\nBuilding plan created with " (itoa numRooms) " rooms."))

(princ)

;;; Helper function to generate room divisions

(defun generateRooms (origin width depth thickness numRooms / roomList

pt1 pt2 pt3 pt4)

(command "_.LAYER" "_S" "A-WALLS" "")

(cond

;; For 2 rooms - simple vertical or horizontal split

((= numRooms 2)

(if (> width depth)

(progn

(setq pt1 (list (+ (car origin) (/ width 2.0)) (cadr origin)))

(setq pt2 (list (+ (car origin) (/ width 2.0)) (+ (cadr origin) depth)))

(command "_.LINE" pt1 pt2 "")

(command "_.OFFSET" thickness (entlast) (list (+ (car origin) (/ width

2.0) (+ (cadr origin) (/ depth 2.0))) "")

(progn

(setq pt1 (list (car origin) (+ (cadr origin) (/ depth 2.0))))

(setq pt2 (list (+ (car origin) width) (+ (cadr origin) (/ depth 2.0))))
 (command "_.LINE" pt1 pt2 "")

(command "_.OFFSET" thickness (entlast) (list (+ (car origin) (/ width

2.0)) (+ (cadr origin) (/ depth 2.0))) "")

(setq roomList (list (list origin (list (+ (car origin) width) (+ (cadr origin)
depth)))))

;; For more rooms - grid layout

((> numRooms 2)

(setq cols (fix (sqrt numRooms)))

(setq rows (fix (+ (sqrt numRooms) 0.999)))

;; Vertical divisions

(repeat (1- cols)

(setq xPos (+ (car origin) (* width (/ (float (1+ (setq i (1+ i)))) cols))))

(setq pt1 (list xPos (cadr origin)))

(setq pt2 (list xPos (+ (cadr origin) depth)))

(command "_.LINE" pt1 pt2 "")

(command "_.OFFSET" thickness (entlast) (list (+ (car origin) (/ width

2.0)) (+ (cadr origin) (/ depth 2.0))) "")

;; Horizontal divisions

(setq i 0)

(repeat (1- rows)

(setq yPos (+ (cadr origin) (* depth (/ (float (1+ (setq i (1+ i)))) rows)))
 (setq pt1 (list (car origin) yPos))

(setq pt2 (list (+ (car origin) width) yPos))

(command "_.LINE" pt1 pt2 "")

(command "_.OFFSET" thickness (entlast) (list (+ (car origin) (/ width

2.0)) (+ (cadr origin) (/ depth 2.0))) "")

;; Create room list with coordinates

(setq roomList (createRoomGrid origin width depth cols rows))

roomList

;;; Create a grid of room coordinates

(defun createRoomGrid (origin width depth cols rows / roomList colWidth

rowHeight i j)

(setq colWidth (/ width cols))

(setq rowHeight (/ depth rows))

(setq roomList nil)

(repeat rows

(setq j (1+ j))

(repeat cols

(setq i (1+ i))

(setq roomList

(cons
 (list

(list (+ (car origin) (* (1- i) colWidth))

(+ (cadr origin) (* (1- j) rowHeight)))

(list (+ (car origin) (* i colWidth))

(+ (cadr origin) (* j rowHeight)))

roomList

(setq i 0)

(reverse roomList)

;;; Place doors in walls

(defun placeDoors (roomList doorWidth wallThk / doorList wall midPt

doorPos)

(command "_.LAYER" "_S" "A-DOORS" "")

(setq doorList nil)

(foreach room roomList

(setq wall (nth (rem (length doorList) 4) '("N" "E" "S" "W")))

(cond

((= wall "N")

(setq midPt (list (/ (+ (caar room) (caadr room)) 2.0) (cadadr room)))
 (setq doorPos (list (- (car midPt) (/ doorWidth 2.0)) (cadr midPt)))

(command "_.LINE" doorPos (list (+ (car doorPos) doorWidth) (cadr

doorPos)) "")

((= wall "E")

(setq midPt (list (caadr room) (/ (+ (cadar room) (cadadr room)) 2.0)))

(setq doorPos (list (car midPt) (- (cadr midPt) (/ doorWidth 2.0))))

(command "_.LINE" doorPos (list (car doorPos) (+ (cadr doorPos)

doorWidth)) "")

((= wall "S")

(setq midPt (list (/ (+ (caar room) (caadr room)) 2.0) (cadar room)))

(setq doorPos (list (- (car midPt) (/ doorWidth 2.0)) (cadr midPt)))

(command "_.LINE" doorPos (list (+ (car doorPos) doorWidth) (cadr

doorPos)) "")

((= wall "W")

(setq midPt (list (caar room) (/ (+ (cadar room) (cadadr room)) 2.0)))

(setq doorPos (list (car midPt) (- (cadr midPt) (/ doorWidth 2.0))))

(command "_.LINE" doorPos (list (car doorPos) (+ (cadr doorPos)

doorWidth)) "")

;; Add door swing arc

 (command "_.ARC"

(if (or (= wall "N") (= wall "S"))

(list (car doorPos) (cadr doorPos))

(list (car doorPos) (cadr doorPos)))

"_C"

(if (or (= wall "N") (= wall "S"))

(list (car doorPos) (+ (cadr doorPos) (if (= wall "N") (- doorWidth)

doorWidth)))

(list (+ (car doorPos) (if (= wall "E") (- doorWidth) doorWidth)) (cadr

doorPos)))

(if (or (= wall "N") (= wall "S"))

(list (+ (car doorPos) doorWidth) (cadr doorPos))

(list (car doorPos) (+ (cadr doorPos) doorWidth)))

(setq doorList (cons (list wall doorPos) doorList))

doorList

;;; Place windows in external walls

(defun placeWindows (origin width depth wallThk winWidth winHeight /

winList)

(command "_.LAYER" "_S" "A-WINDOWS" "")

(setq winList nil)

;; North wall windows

(setq numWindows (fix (/ width (+ winWidth 1.0))))

 (setq spacing (/ (- width (* numWindows winWidth)) (1+ numWindows)))

(repeat numWindows

(setq xPos (+ (car origin) (* spacing (setq i (1+ i))) (* winWidth (1- i))))

(setq yPos (+ (cadr origin) depth (- wallThk)))

(command "_.LINE"

(list xPos yPos)

(list xPos (- yPos winHeight))

"")

(command "_.LINE"

(list (+ xPos winWidth) yPos)

(list (+ xPos winWidth) (- yPos winHeight))

"")

(command "_.LINE"

(list xPos (- yPos (/ winHeight 2.0)))

(list (+ xPos winWidth) (- yPos (/ winHeight 2.0)))

"")

(setq winList (cons (list "N" (list xPos yPos)) winList))

;; Repeat for East, South, West walls...

;; (Similar logic for other walls - omitted for brevity)

winList

;;; Label rooms with numbers

(defun labelRooms (roomList / roomNum roomCenter)

(command "_.LAYER" "_S" "A-TEXT" "")

(setq roomNum 1)

(foreach room roomList

(setq roomCenter

(list

(/ (+ (caar room) (caadr room)) 2.0)

(/ (+ (cadar room) (cadadr room)) 2.0)

(command "_.TEXT"

"_J" "_MC"

roomCenter

0.5 ; Text height

0 ; Rotation

(strcat "ROOM " (itoa roomNum))

(setq roomNum (1+ roomNum))

;;; Main command to generate building plan

(defun c:GENBUILDING ()

(alert "This command will generate a building plan.\nSpecify parameters in

the dialog or command line.")

(c:BUILDINGPLAN)
)

(princ "\nBuilding plan generator loaded. Type GENBUILDING to start.")

(princ)