Back to General and Gameplay Programming

Lisp Pimpin'

Nathan Baum · 2005-09-10T14:49:32

I figured it was about time I pimped mo' Lisp on yo asses. (defpackage turbine (:use) (:nicknames tb)) (defconstant tb::*fail* 'tb::*fail*) (defmethod tb::fail () (block nil (handler-bind ((control-error #'(lambda (&rest ignore) (return)))) (throw tb::*fail* tb::*fail*)))) (defmacro tb::fail-if (test value) (if test value (tb::fail))) (shadow 'with-gensyms) (defmacro with-gensyms (syms &body body) `(let ,(mapcar #'(lambda (sym) `(,sym (gensym))) syms) ,@body)) (defmacro defpredicate (name pred) `(defmethod ,name (&rest args) (if (apply #',pred args) (car (last args)) (tb::fail)))) (defmacro tb::suspend (value &body forms) `(values ,value #'(lambda () ,@forms))) (defun tb::make-generator (fn init-args) (let ((the-fn #'(lambda () (apply fn init-args)))) #'(lambda () (if (null the-fn) (tb::fail) (multiple-value-bind (result new-fn) (funcall the-fn) (setf the-fn new-fn) result))))) (defmacro tb::defgen (name lambda-list &body body) `(setf (get (defun ,name ,lambda-list ,@body) 'tb::generator) t)) (setf (get 'tb::iota 'tb::generator) t) (defun genfunp (symb) (get symb 'tb::generator)) (defun extract-generators (form) (let (names forms) (labels ((addgen (name form) (setf names (cons name names) forms (cons form forms))) (walker (form) (cond ((not (consp form)) form) ((or (not (consp (car form))) (not (genfunp (caar form)))) (cons (walker (car form)) (walker (cdr form)))) (t (with-gensyms (gen-name) (addgen gen-name `(tb::make-generator #',(caar form) ,(cdar form))) `(,gen-name ,@(walker (cdr form)))))))) (let ((x (walker (list form)))) (values (reverse names) (reverse forms) (car x)))))) (defmacro tb::if (test then else) (let ((block-name (gensym)) (tag (gensym))) `(block ,block-name (catch ',tag (catch 'tb::*fail* (throw ',tag ,test)) (return-from ,block-name ,else)) ,then))) (defun closure-reader (stream char) (declare (ignore char)) `(lambda (&rest args) (destructuring-bind (&optional _1 _2 _3 _4 _5 _6 _7 _8 _9 &rest _>) args (let ((_ _1) (_* args)) ,@(read-delimited-list #\] stream t))))) (set-macro-character #\[ #'closure-reader nil) (set-macro-character #\] #'(lambda (stream char) t) t) (defmacro tb::every (subject &body body) (with-gensyms (loop-name ever-successful result) (multiple-value-bind (symbol-names init-forms subject) (extract-generators subject) (let ((init-args (mapcar [(gensym)] init-forms))) `(let ,(mapcar [`(,_1 (list ,@(third _2)))] init-args init-forms) ,(let ((init-forms (mapcar [(list (first _2) (second _2) _1)] init-args init-forms))) (let ((fnames (mapcar [(gensym)] init-forms))) `(let ,(mapcar [`(,_1 ,_2)] fnames init-forms) (let ,(mapcar [`(,_1 (funcall ,_2))] symbol-names fnames) (let* ((,ever-successful nil) (,result (loop named ,loop-name do (tb::if ,subject (tb::guard (setf ,ever-successful t) ,@body) nil) do ,(with-gensyms (block-name) `(block ,block-name ,@(mapcar [`(tb::if (setf ,_1 (funcall ,_2)) (return-from ,block-name) (progn (setf ,_2 ,_3) (setf ,_1 (funcall ,_2))))] symbol-names fnames init-forms) (return-from ,loop-name)))))) (if ,ever-successful ,result (tb::fail)))))))))))) (import '(t nil) 'tb) (defmacro tb::guard (&body forms) `(catch 'tb::*fail* ,@forms)) (defmacro tb::or (&rest forms) (with-gensyms (block-name) `(block ,block-name ,@(mapcar #'(lambda (form) `(tb::guard (return-from ,block-name ,form))) forms)))) (defmethod tb::identical? (x y) (tb::fail-if (eq x y) y)) (defmethod tb::equal? (x y) (tb::fail-if (equalp x y) y)) (import '(1- 1+ + * - / max min abs) 'tb) (defpredicate tb::> >) (defpredicate tb::< <) (defpredicate tb::>= >=) (defpredicate tb::<= <=) (defpredicate tb::/= [(not (equalp _1 _2))]) (defpredicate tb::== equalp) (defpredicate tb::even? [(evenp _)]) (defpredicate tb::integer? integerp) (defmacro tb::not (form) `(tb::if ,form (tb::fail) nil)) (defmacro tb::and (&rest args) `(progn ,@args)) (import '(format setq) 'tb) (import '(&optional &rest &body &key) 'tb) (in-package tb) (defgen iota (from to &optional (by 1)) (if (>= from to) from (suspend from (iota (+ from by) to)))) That beautiful flower is the beginnings of the definition of a minilanguage similar in spirit to the Icon programming language. Predicates either succeed, producing their last argument as a value, or fail, producing no value and short-circuiting evaluation up to the nearest failure guard. Generators produce sequences of values, and the every form repeatedly evaluates an expression until all generators are exhausted, executing the body for those iterations where the test was successful. If no tests where successful, the every fails as a whole. In the completed language, one would be able to do things like (if (== (one-of foo bar baz) (gen 10 20 30)) (print "One of foo, bar or baz is equal to 10, 20 or 30")), or (print "Foo appears before bar in \"" string "\" in positions: ") (every (print (> (find string "foo") (find string "bar"))) " "). Right now, it allows for stupidly concise, although terribly inefficient (I'm no compiler writer), code like the following: (every (setq i (iota 1 100)) (format t "~A is prime~%" i (not (every (> i (integer? (/ i (iota 1 (1- i)))) 1))))) Roughly, it says: For every i from 1 to 100, say it's prime if there are no numbers from 1 to i - 1 by which i is divisible. The particularly odd thing is not simply conciseness -- in the prime number case, the program could be equally concise in almost any language -- but the fact that the algorithm can be turned inside out, if that happens to suit the problem at hand: compare (every (print (> (find string "foo") (find string "bar"))) with an equivalent in your favourite programming language. The fact that I'm able to knock up something this weird in only several hours, which interacts almost seamlessly with standard Lisp (only almost, sadly) is telling of Lisp's deep-rooted flexibility. In summary: Lisp rox your sox. PS. If you feel like trying it out, I only know it works in CLISP. Plus, I've only been testing it for about 4 hours. Plan accordingly.

General and Gameplay Programming Programming

Started by Nathan Baum July 13, 2005 01:07 AM

387 comments, last by Mercury 18 years, 7 months ago

CoffeeMug

852

July 14, 2005 01:25 PM

Quote:Original post by Max_Payne
Well, considering I'm mostly interested in graphics and 3D engines, you'd have to convince me that lisp can help me write simple, clean and very efficient code.

I don't really have to convince you. Effectively, we're doing you a favor by spending time trying to convince you to take the time and enlighten yourself. You can treat it as free career counseling. That's how I prefer to think about the discussions I've had with Lispers when I was in your shoes.

[smile]

defmacro.org

Max_Payne

757

July 14, 2005 01:27 PM

Quote:Original post by CoffeeMug
Quote:Original post by Max_Payne
Well, considering I'm mostly interested in graphics and 3D engines, you'd have to convince me that lisp can help me write simple, clean and very efficient code.

I don't really have to convince you. Effectively, we're doing you a favor by spending time trying to convince you to take the time and enlighten yourself. You can treat it as free career counseling. That's how I prefer to think about the discussions I've had with Lispers when I was in your shoes.

"Enlighten" eh?

As it was said before, you Lisp people should start a religion or something ;)

And well, I don't think you ever were in my shoes.

The main reason I'm not convinced, is that I don't really feel like theres a problem in the first place. The thing I feel is most uncomfortable in C++ is the lack of support for multithreading and other important OS-dependent facilities in the standard libraries.

Looking for a serious game project?
www.xgameproject.com

demonkoryu

980

July 14, 2005 01:31 PM

On a side question, can you recommend a Lisp/Scheme implementation suitable as an extension language for games? I have looked into Guile, but I am not sure if this is the best thing for the task.

CoffeeMug

852

July 14, 2005 01:32 PM

Quote:Original post by Max_Payne
"Enlighten" eh?

I can't describe the experience of grokking Lisp in any other way. Learning it is very frustrating until a certain "ohhh shit..." experience at which point you experience a certain feeling not unlike nirvana.

Quote:Original post by Max_Payne
And well, I don't think you ever were in my shoes.

Considering I've used the same exact arguments as you are now, I think I was in your shoes at least as far as the topic of discussion is concerned.

defmacro.org

HairyTroll

192

July 14, 2005 01:35 PM

Ok. I wrote some code in Lisp to simplify sprite animation. The following code will move *sprite* to a random location every 0.5 seconds for a total of 5 seconds.

(animate *sprite*	 (init ((random-jump (make-instance 'random-jump					    :max-x 418					    :max-y 320))))	 (cue (and (every 500) (until 5000))	      (action random-jump *sprite*)))

That's it.

[Edit - added the following explanation]

Some explanation:

'animate' is called every game loop. However everything in 'init' is only called once. Here we use 'init' to create the 'random-jump' action - this must be done the first time 'animate' is run.

'cue' is run for each game loop. 'cue' checks that the following are true before running the action:

- 'every' returns true every x milliseconds.
- 'until' retuns true until > x milliseconds.

Max_Payne

757

July 14, 2005 01:35 PM

Quote:Original post by CoffeeMug
I can't describe the experience of grokking Lisp in any other way. Learning it is very frustrating until a certain "ohhh shit..." experience at which point you experience a certain feeling not unlike nirvana.

The Lisp will make you happy. The Lisp will make you beautiful. Now, let us all medidate in front of the holy Lisp statue.

Quote:Considering I've used the same exact arguments as you are now, I think I was in your shoes at least as far as the topic of discussion is concerned.

Considering many of my arguments are responses to your own arguments, that wouldn't make much sense ;)

Looking for a serious game project?
www.xgameproject.com

CoffeeMug

852

July 14, 2005 01:38 PM

Quote:Original post by Konfusius
On a side question, can you recommend a Lisp/Scheme implementation suitable as an extension language for games?

I would suggest rolling your own. Writing Lisp interpreters is frankly extremely easy. If you know Lisp barely, I'd suggest this as well. As long as you use trivial Lisp principles you'll end up designing the language. You'll find that your design will end up very similar to the actual Lisp design as there is a natural way to do things (to which you'll arrive on your own). That will increase your understanding of Lisp tremendously. I really recommend taking the time to do it. It'll be worth it many times over.

defmacro.org

CoffeeMug

852

July 14, 2005 01:40 PM

Quote:Original post by Max_Payne
Quote:Considering I've used the same exact arguments as you are now, I think I was in your shoes at least as far as the topic of discussion is concerned.

Considering many of my arguments are responses to your own arguments, that wouldn't make much sense ;)

? I'm talking about me arguing against Lisp a couple of years ago same way you're doing now.

defmacro.org

demonkoryu

980

July 14, 2005 01:41 PM

Quote:Original post by CoffeeMug
I would suggest rolling your own.

Thank you. I will give it a shot.

Max_Payne

757

July 14, 2005 01:41 PM

Quote:Original post by CoffeeMug
Quote:Original post by Konfusius
On a side question, can you recommend a Lisp/Scheme implementation suitable as an extension language for games?

I would suggest rolling your own. Writing Lisp interpreters is frankly extremely easy. If you know Lisp barely, I'd suggest this as well. As long as you use trivial Lisp principles you'll end up designing the language. You'll find that your design will end up very similar to the actual Lisp design as there is a natural way to do things (to which you'll arrive on your own). That will increase your understanding of Lisp tremendously. I really recommend taking the time to do it. It'll be worth it many times over.

I think thats a neat idea as far as learning is concerned (I am tempted to try it :D).

However, if you are concerned with speed, you should at least need to compile the Lisp code into a simple AST.

Looking for a serious game project?
www.xgameproject.com

Lisp Pimpin'

This topic is closed to new replies.

Popular Topics

Recommended Tutorials

Lisp Pimpin'

This topic is closed to new replies.

Popular Topics

Recommended Tutorials

Reticulating splines