lambdaisland.witchcraft.cursor — com.lambdaisland/witchcraft 0.32.303

Logo-like API for drawing blocks by using a walking metaphor.

This is a functional API, movements simply build up a list of block positions, call build! at the end to actually make them materialize in the game.

A cursor contains a current location (x/y/z), a directions (:north, :north-east, :east, etc.), and a current building material, e.g :lapis-block (see lambdaisland.witchcraft/materials).

It also contains a drawing flag :draw? and a list of blocks :blocks. When drawing is on, then any step will add a block to the list. build! creates blocks in the world based on this, and resets the list.

Call start to get an initial cursor, this will return a cursor that is one step ahead of the player (so what you draw is in sight), facing away from the player.

(require '[lambdaisland.witchcraft.cursor :as c])

(-> (c/start)
    (c/draw)
    (c/material :red-glazed-terracotta)
    (c/steps 3)
    (c/rotate 2)
    (c/material :blue-glazed-terracotta)
    (c/steps 3)
    (c/rotate 2)
    (c/material :green-glazed-terracotta)
    (c/steps 3)
    (c/rotate 2)
    (c/material :yellow-glazed-terracotta)
    (c/steps 3)
    (c/build)
    )

?block clj

(?block c)

Add a block to the block list based on the current cursor location and material, but only if drawing is enabled. (pronounced "maybe block")

apply-matrix clj

(apply-matrix {:keys [origin dir] :as c} matrix)

Apply a single matrix to a single x/y/z map based on the origin.

block clj

(block {:keys [matrices block-fn] :as c :or {block-fn block-fn}})

Add a block to the block list based on the cursor location.

Will set multiple blocks if symmetries are defined, see [[reflect]].

block-data clj

(block-data cursor prop-map)

Set the BlockData block-data (post-flattening and material-dependent).

block-facing clj

(block-facing cursor dir)

Make the cursor produce blocks with the specified direction.

block-fn clj

(block-fn c)

block-value clj

(block-value {:keys [x y z material block-data block-facing data palette dir
                     face-direction? rotate-block]
              :as loc})

Get the x/y/z and material data for the current cursor, so we can use it to create a block. This also resolves any palette indirection for the material. If the material is a two-element vector (either explicitly or via the palette) then this is taken as [material material-data], and overrides the material-data in the cursor.

blocks clj

(blocks {:keys [blocks] :as cursor})

Get the set of blocks placed by the cursor

build clj deprecated

See build!

build! clj

(build! cursor)

(build! {:keys [blocks] :as cursor} opts)

Apply the list of blocks in the cursor to the world.

default-material clj

Material used if no material is specified. This one has an arrow on it, which will show the direction the cursor is moving into.

directions clj

draw clj

(draw c)

(draw c draw?)

Enable/disable drawing. Enables by default, pass false to disable.

excursion clj

(excursion cursor f & args)

Apply a block-drawing function f, then return to the original position.

extrude clj

(extrude cursor n)

(extrude cursor n dir)

Take the current block list and extrude it in a given direction, by default up.

face clj

(face cursor dir)

Face the cursor in a certain direction

face-direction? clj

(face-direction? cursor bool)

Should the direction blocks are facing be based on the direction of the cursor?

flash! clj

(flash! c)

(flash! c timeout)

Like build, but shortly after undoes the build again

This is meant for REPL use where you can rapidly try out changes before committing to them.

material clj

(material c m)

(material c m md)

Set the current cursor material, and optionally material-data (integer), or block-data (map), to be used for consecutive blocks. Material can be a keyword, a vector of [material block-data], or a function which takes the current cursor and returns a material.

material->keyword clj

matrices clj

(matrices c & matrices)

Set matrices

move clj

(move cursor)

(move {:keys [draw? dir] :as cursor} n)

(move {:keys [draw?] :as cursor} n dir)

(move c n dir & more)

Move the cursor as with steps, but without drawing. Retains the cursor direction.

move-to clj

(move-to cursor loc)

Move the cursor to the given location, does not draw.

movements clj

origin clj

(origin c & a)

Set the origin around which matrix operations are performed

palette clj

(palette c m)

Add items to the palette. Takes a single map.

pattern clj

(pattern c pattern)

Draw a number of steps in a line, based on a sequence of materials. Note that in combination with palette this can also take a string, assuming you've added palette entries for the given characters.

relative-movements clj

reps clj

(reps c n f & args)

Perform a function n times on the cursor

resolve-dir clj

(resolve-dir facing asked)

Helper for dealing with forward/left/right type of directions, instead of east/north/west.

restore-block-facing clj

(restore-block-facing cursor old-cursor)

Restore the attributes related to block-facing from old-cursor.

rotate clj

(rotate {:keys [dir xy-dir] :as cursor} n)

Rotate the cursor clockwise by a number of 1/8 turns clockwise.

rotate-dir clj

(rotate-dir dir n)

Given a direction keyword like :north or :south and a number, make that many 1/8 turns clockwise.

(rotate :north 4) ;; => :south

rotation clj

(rotation cursor n)

Specify a relative rotation in 1/8 turns clockwise. Blocks will still be aligned based on the cursor direction, but then additionally given this much rotation. Useful in case your blocks are not aligning with the draw line in the way that you wanted.

start clj

(start)

(start loc)

(start loc dir)

Creates a new cursor, starting at the given location, or one step in front of the player's location.

step clj

(step cursor)

(step {:keys [step-fn] :or {step-fn step-fn} :as cursor} dir)

(step cursor dir & dirs)

Take one step forward in the direction given, or the direction the cursor is facing. If drawing is enabled this will also add a block to the block list corresponding with the new location.

step-fn clj

(step-fn c dir)

Default implementation of how a single step happens, i.e. determine the direction and update :x / :y / :z accordingly. Can be overruled by adding a :step-fn to the cursor.

steps clj

(steps cursor n)

(steps cursor n dir)

(steps cursor n dir & more)

Take n steps forward as with step, or in the direction specified. Can take multiple number/direction pairs to do a full walk. Will change the direction of the cursor to the direction of the final step.

symmetry-xz clj

(symmetry-xz c)

translate clj

(translate c offset)

Move all blocks in the block set, as well as the cursor, by a given offset.

valid-movements clj