My Doctor's visits usually break down something like this:

• 99% waiting
• 0.9% in some kind of new visit induced pain
• 0.1% getting the information I came for

Along the way there's something like a 50% probability I'll be asked to remove my pants.

On the whole, it's not something I enjoy but having a Kindle solves 99% of it.

Hi there.

I've just published my first Android game. It's simple, but I'm proud of it. It's one of several (unfortunately) games named "Memory Match" in the Android store. You can either search the store for "wubo" or you can just follow this direct link and let me know what you think.

I'm open to suggestions in the comments either here or in the market.

I just finished implementing the rules for when to draw shadows on a tile and what shadows to draw. The creator of the "Planet Cute" tileset includes this very helpful guide:

Thankfully, before I wasted too much time, I realized this was just the sort of thing that I could write a small DSL to describe. Here's my mapping to code of the image above:

(def *shadow-types*
     [(shadow-with :shadow-south-east
                   (present [1 1 1])
                   (absent [1 0 1]))
      (shadow-with :shadow-east
                   (present [1 0 1]))
      (shadow-with :shadow-north-east
                   (present [1 -1 1])
                   (absent [1 -1 0])
                   (absent [1 0 1]))
      (shadow-with :shadow-side-west
                   (present [0 1 -1])
                   (absent [0 1 0]))
      (shadow-with :shadow-south
                   (present [1 1 0]))
      (shadow-with :shadow-north
                   (present [1 -1 0]))
      (shadow-with :shadow-south-west
                   (present [1 1 -1])
                   (absent [1 0 -1]))
      (shadow-with :shadow-west
                   (present [1 0 -1]))
      (shadow-with :shadow-north-west
                   (present [1 -1 -1])
                   (absent [1 -1 0])
                   (absent [1 0 -1]))])

And the resulting shadowed image:

The updated code is up on github.

I just created a new repository up on GitHub.

https://github.com/netguy204/platformer

My current vision is to create a game with a play style somewhat like a classic platformer. I'm doing that because I think I can achieve the basic rendering/controls/collisions pretty quickly and can focus on what I really want to do: Physics!

Ah, the real motivation.

I recently purchased the excellent Game Physics Engine Development by Ian Millington and I want to make a sandbox that I can use to play with the things that I'm learning.

I'm also using the very handy "Planet Cute" tile set from lostgarden.

http://www.lostgarden.com/2007/05/dancs-miraculously-flexible-game.html

All I have now is a renderer. Naturally (given my current obsession) I'm working in closure. Here's a level definition:

(def *scene*
     [[[:stone :stone :brown]
       [:stone :brown :brown]
       [:stone :dirt :dirt]]
      [[:none :none :chest]
       [:none :none :none]
       [:none :dirt :dirt]]])

And here's what that looks like rendered:

I need to add some shadows so that the height of one tile relative to another is less ambiguous.

I've been porting my org-mode blogging system to Clojure from Rails. So far, I've been pretty blown away by how fantastically-good the tools for doing web-development in Clojure are!

For doing webdev in Clojure, I've finally found the secret ingredients: Enlive and Moustache. Enlive is a really solid template library that lets you extract, mutate, and re-assemble chunks of HTML primordial ooze into data-rich goodness.

(deftemplate page-template *page*
  [{:keys [title blurb body]}]

  [:title] (maybe-content title)
  [:#page_title] (maybe-content title)

  [:#about :p] (maybe-content blurb)
  [:#buttons] (content (map button-model *buttons*))

  [:#page_content] (content body))

<!-- just a snippet -->
  <div id="buttons">
    <a class="button" href="/"><span>Projects</span></a>
    <a class="button" href="/"><span>Blog</span></a>
    <a class="button" href="/"><span>Github</span></a>
  </div>

  <div id="page_content">
    <h2 class="post_title">The Title</h2>
    <div class="post_timestamp">posting time</div>
    <div class="post_body">
    </div>
  </div>
<!-- just a snippet -->

[:#page_content] (content body)

(def *post-sel* [:#page_content])

(defsnippet post-model *page* *post-sel*
  [{:keys [title timestamp body] :or {:timestamp ""}}]
  [:.post_timestamp] (content timestamp)
  [:.post_title] (content title)
  [:.post_body] (html-content body))

(def routes
     (app
      wrap-params
      [""] (with-template
             (page-template {:title "Brian's Site"
                             :body (map post-model (all-posts))}))

      ["entry" id] (with-template
                    (let [post (get-post-id id)]
                      (page-template {:title (:title post)
                                      :body (post-model post)})))
      ["atom.xml"] (with-template
                     (atom-template (atom-date)
                                    (map atom-storify (all-posts))))
      ["post"] {:post new-post}))

["entry" id] (with-template
              (let [post (get-post-id id)]
                (page-template {:title (:title post)
                                :body (post-model post)})))

I'm a fledgling user of the very excellent emacs org-mode. I'm finding that I gravitate to it naturally for capturing everything from quick TODO items to detailed notes and plans. It's amazing how a simple outline is really most of what I need to organize my day.

I've been dabbling in elisp lately trying to build some way to post some of those thoughts to something resembling a blog. Here's what I came up with:

This code extracts the org sub-tree that contains point and splits it into the title and body. Then it converts the body to HTML using org-mode's HTML export feature.

(defun orgblog-post-file ()
  (interactive)
  (save-excursion
    (let (title-beg title-end body-beg body-end title body)
      (setq title-beg (progn (org-back-to-heading) (point)))
      (setq title-end (progn (end-of-line) (point)))
      (setq body-beg (progn (beginning-of-line 2) (point)))
      (setq body-end (progn (org-end-of-subtree) (point)))
      (setq title (buffer-substring-no-properties title-beg title-end))
      (setq body (org-export-region-as-html body-beg body-end t 'string))
      (orgblog-post orgblog-post-url (list (cons "title" title)
                                           (cons "body" body))))))

Then this accomplishes the fairly simple task of building an HTTP POST request and passing those parameters up to the brain-dead simple web-api I slapped onto my blog.

(defun orgblog-post (url args)
  "send ARGS to URL as a post request"
  (let ((url-request-method "POST")
        (url-request-extra-headers
         '(("Content-Type" . "application/x-www-form-urlencoded")
           ("Accept" . "application/json")
           ("Connection" . "close")))
        (url-request-data
         (mapconcat (lambda (arg)
                      (concat (url-hexify-string (car arg))
                              "="
                              (url-hexify-string (cdr arg))))
                    args
                    "&")))
    (url-retrieve url 'orgblog-post-response)))

I'm sure there are far better ways to do this but this meets my needs and means that I can finally make blog posts without the distraction and frustration of leaving the work-environment I am most comfortable in.