quip.sprite — com.kimbsy/quip 4.0.3

Sprites, for drawing and animating game objects.

The basic sprites provided are useful if simple, feel free to implement your own.

animated-sprite clj

(animated-sprite sprite-group
                 pos
                 w
                 h
                 spritesheet-file
                 &
                 {:keys [rotation vel update-fn draw-fn animations
                         current-animation points bounds-fn offsets extra]
                  :or {rotation 0
                       vel [0 0]
                       update-fn update-animated-sprite
                       draw-fn draw-animated-sprite!
                       animations {:none
                                     {:frames 1 :y-offset 0 :frame-delay 100}}
                       current-animation :none
                       offsets [:center]
                       extra {}}})copy

default-bounding-poly clj

(default-bounding-poly {:keys [w h]})copy

Generates a bounding polygon based off the w by h rectangle of the sprite.

draw-animated-sprite! clj

(draw-animated-sprite! {:keys [pos rotation w h spritesheet current-animation
                               animation-frame]
                        :as s})copy

draw-default! clj

(draw-default! {:keys [pos w h] :as s})copy

draw-image-sprite! clj

(draw-image-sprite! {:keys [pos rotation image] :as sprite})copy

draw-scene-sprites! clj

(draw-scene-sprites! {:keys [current-scene] :as state})copy

Draw each sprite in the current scene using its :draw-fn.

draw-scene-sprites-by-layers! clj

(draw-scene-sprites-by-layers! {:keys [current-scene] :as state} layers)copy

Draw each sprite in the current scene using its :draw-fn in the order their :sprite-group appears in the layers list.

Any sprites with groups not found in layers will be drawn last.

draw-text-sprite clj

(draw-text-sprite {:keys [content pos offsets font size color]})copy

has-group clj

(has-group sprite-group)copy

Creates a predicate function that filters sprites based on their :sprite-group.

Takes either a single :sprite-group keyword, or a collection of them.

Commonly used alongside update-sprites-by-pred:

(sprite/update-sprites-by-pred state (sprite/has-group :asteroids) sprite-update-fn)

(sprite/update-sprites-by-pred state (sprite/has-group [:asteroids :ships]) sprite-update-fn)

image-sprite clj

(image-sprite sprite-group
              pos
              w
              h
              image-file
              &
              {:keys [rotation vel update-fn draw-fn points bounds-fn offsets
                      extra]
               :or {rotation 0
                    vel [0 0]
                    update-fn update-pos
                    draw-fn draw-image-sprite!
                    offsets [:center]
                    extra {}}})copy

is-sprite clj

(is-sprite {:keys [uuid]})copy

memo-graphics clj

pos-offsets clj

(pos-offsets {[x-off y-off] :offsets :keys [w h]})copy

Determine the x and y offsets for a sprite based on it's :w, :h and :offsets configuration.

Defaults to [:center :center].

set-animation clj

(set-animation s animation)copy

sprite clj

(sprite sprite-group
        pos
        &
        {:keys [w h vel update-fn draw-fn points bounds-fn offsets extra]
         :or {w 20
              h 20
              vel [0 0]
              update-fn update-pos
              draw-fn draw-default!
              offsets [:center]
              extra {}}})copy

The simplest sensible sprite.

Contains a position, velocity, dimensions for collision detection, can be enriched with any custom fields via the :extra kwarg.

text-sprite clj

(text-sprite content
             pos
             &
             {:keys [offsets sprite-group font size color update-fn draw-fn
                     extra]
              :or {offsets [:center]
                   sprite-group :text
                   font u/default-font
                   size u/default-text-size
                   color u/black
                   update-fn identity
                   draw-fn draw-text-sprite
                   extra {}}})copy

update-animated-sprite clj

(update-animated-sprite s)copy

update-animation clj

(update-animation {:keys [current-animation delay-count] :as s})copy

update-frame-delay clj

(update-frame-delay {:keys [current-animation] :as s})copy

update-pos clj

(update-pos {:keys [pos vel] :as s})copy

update-sprites clj

(update-sprites state f)copy

(update-sprites {:keys [current-scene] :as state} pred f)copy

Update sprites in the current scene with the update function f.

Optionally takes a filtering function pred.

update-state clj

(update-state {:keys [current-scene] :as state})copy

Update each sprite in the current scene using its :update-fn.