Community
Granting these conditions
Layers PPM_1 to PPM_20 are existing
Blocks with same name as layers are existing
(defun c:test (/ Rolling num)
(defun Rolling (prcnt)
(repeat prcnt
(setq prcnt_1 (1+ prcnt))
(prompt "\r|")(prompt "\r/")
(prompt "\r|")(prompt "\r\\")
(princ)
)
)
(setq num 21)
(command "_.layer" "off" "PPM*" "")
(repeat (1- num)
(command "_.layer" "_On" (strcat "PPM_" (itoa (setq num (1- num))))"")
(rolling 1000)
)
)
The duration of the delay can be controlled by prnct argument (rolling 1000)<---- this value
Limited testing
Hope this helps
I wondered about some different ways of doing some of those things -- you may find some of them worthwhile, and not others. Consider this:
(defun C:ANIM-PPM (/ lay laylist del cycles cmde script); = ANIMation of things on PPM* Layers
(while (setq lay (cdadr (tblnext "layer" (not lay))))
(if (= (substr lay 1 3) "PPM")
(setq laylist (cons lay laylist)); list of all PPM* Layers
); end if
); end while
(while
(not
(and
(setq del (getint "\nSpeed [1=fastest, 10=slowest]: "))
(< 0 del 11); within range
); end and
); end not
(prompt "\nOutside of allowable range --")
); end while
(initget 7); no Enter, no 0, no negative
(setq
cycles (getint "Number of animation cycles: ")
laylist (vl-sort laylist '<); Layer names in order of end number
cmde (getvar 'cmdecho)
); end setq
(setvar 'cmdecho 0)
(command "_.layer" "_set" "0" "_off" "PPM*" ""); start condition
(repeat cycles
(foreach lay laylist
(command
"_.layer" "_off" "PPM*" "_on" lay ""
"_.delay" (* del 10); <--- adjust 10 multiplier basis as desired
); end command
); end foreach
); end repeat
(setvar 'cmdecho cmde)
(princ)
); end defun
The first part makes a list of all Layer names starting with "PPM". That means there's no need to have a particular number of them built in to the drawing or the routine [it could be different in different drawings], and you don't need to count through that number in the animation, so you don't need to increment a variable for that, nor construct Layer names to turn on using the ""PPM_" prefix and the number variable that needs to be converted to text -- the (foreach) later on just steps through for you.
The next part, setting the 'del' variable for the speed, is maybe no better than your approach. I was just trying something that didn't require the long (initget) to spell out all the possibilities, nor the conversion of the User's input from text to a number.
The 'cycles' variable is just an alternative approach to how long to run it, which seemed to me more direct and simpler to work with, using a simple (repeat) function, than the duration approach, but again, not necessarily better.
Finally, the DELAY command is described in Help as being for use in Scripts, but it does also work in Lisp (command) functions, at least for me back here in 2004 and for others in the Discussion Group history. Your other way of causing a frame-to-frame delay is a kind of "workaround" approach, basically built to force the computer to waste some time, but Delay is very straightforward.
Kent Cooper, AIA 
@stevesfr wrote:Ok, how about we turn on all layers when finished ?
That would be very easy to do:
....
); end foreach
); end repeat
(command "_.layer" "_on" "*" "")
(setvar 'cmdecho cmde)
(princ)
); end defun
But that may or may not be wanted. A user might start the routine when some but not all other Layers, unrelated to the routine, are turned off, and want to return to that condition. Saving a Layer State is iffy, depending on what options it's set to look at. But since the routine doesn't change any objects other than the display of them, or add or remove any objects, putting an UNDO Mark at the beginning and an UNDO Back at the end would take it back to whatever the state of things was:
(defun C:ANIM-PPM (/ lay laylist del cycles cmde script); = ANIMation of things on PPM* Layers
(command "_.undo" "_mark")
(while (setq lay (cdadr (tblnext "layer" (not lay))))
....
); end repeat
(command "_.undo" "_back")
(setvar 'cmdecho cmde)
(princ)
); end defun
Kent Cooper, AIA
@Anonymous wrote:Kent, I did make one small change, I commented out the vl-sort. If you have more than 10 layers than the sort order ends of being incorrect .... So as long as the layers were created in numerical order they will be acquired in that order (at least from my observation). ....
Ah, yes.... The things you don't think of when you try a simple test -- I did it with only five Layers. I agree, creation order is how (tblnext) steps through things.
EDIT 1: If you might not always make them strictly in order, you could use double-digit number endings for all of them, e.g. PPM_00, PPM_01, etc., and keep the sorting function.
EDIT 2: The way it makes the list of Layer names, they'll be in reverse order from the order of creation, so if that matters, you'll want to (reverse) the list, rather than (vl-sort) it.
Kent Cooper, AIA
@Kent1Cooper wrote:.... If you might not always make them strictly in order, you could use double-digit number endings for all of them, e.g. PPM_00, PPM_01, etc., and keep the sorting function.....
Or, you could sort them more intelligently, to account for the variable-numbers-of-digits Layer-name-ending possibility, for instance like this [see also other notes following]:
(defun C:ANIM-PPM (/ *error* lay laylist del cycles cmde script); = ANIMation of things on PPM* Layers
(defun *error* (errmsg)
(if (not (wcmatch errmsg "Function cancelled,quit / exit abort,console break"))
(princ (strcat "\nError: " errmsg))
); end if
; (command "_.undo" "_back"); didn't work, somehow
(command "_.undo" "_end" "_u")
(setvar 'cmdecho cmde)
(princ)
); end defun - *error*
; (command "_.undo" "_mark"); didn't work, somehow
(command "_.undo" "_begin")
(setq cmde (getvar 'cmdecho))
(while (setq lay (cdadr (tblnext "layer" (not lay))))
(if (= (substr lay 1 3) "PPM")
(setq laylist (cons lay laylist)); list of all PPM* Layers
); end if
); end while
(while
(not
(and
(setq del (getint "\nSpeed [1=fastest, 10=slowest]: "))
(< 0 del 11); within range
); end and
); end not
(prompt "\nOutside of allowable range --")
); end while
(initget 7); no Enter, no 0, no negative
(setq
cycles (getint "Number of animation cycles: ")
; laylist (vl-sort laylist '<); Layer names in too-simple order of end number
; laylist (reverse laylist); Layer names in order of creation
laylist
(vl-sort ; Layer names in intelligent order of end number, regardless of creation order
laylist
'(lambda (x y) (< (atoi (substr x 5)) (atoi (substr y 5))))
; depends on "PPM_" [or other 4-character] beginning for all names, and integer ending
); end vl-sort & laylist
); end setq
(setvar 'cmdecho 0)
(command "_.layer" "_set" "0" "_off" "PPM*" ""); start condition
(repeat cycles
(foreach lay laylist
(command
"_.layer" "_off" "PPM*" "_on" lay ""
"_.delay" (* del 10); <--- adjust 10 multiplier basis as desired
); end command
); end foreach
); end repeat
; (command "_.undo" "_back"); didn't work, somehow
(command "_.undo" "_end" "_u")
(setvar 'cmdecho cmde)
(princ)
); end defun
I incorporated the return of the initial Layer conditions as discussed with stevesfr, but for some reason I can't figure out, using Undo Mark and Undo Back didn't work -- it told me I needed to enter Undo End to go back further, even though I hadn't used Undo Begin anywhere. If anyone can identify why it wouldn't work with the commented-out lines, I'd be interested. It may also be affected by the AutoCAD version [I'm back in 2004]. But I found a way around it, using Begin/End and another U to undo the grouped operations.
And I put in error handling, so that if, for instance, someone has a long one going and decides they don't want to see it through to the end, they can hit Escape to get out of it, and it will still return the Layer situation as it was when they started.
Kent Cooper, AIA
@Kent1Cooper wrote:(command_delay, thats brilliant Kent
"_.layer" "_off" "PPM*" "_on" lay ""
"_.delay" (* del 10); <--- adjust 10 multiplier basis as desired
); end command
Forums Links
Can't find what you're looking for? Ask the community or share your knowledge.
Post to forums
