lambdaisland.witchcraft.cursor — com.lambdaisland/witchcraft 0.6.142

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-fn clj

(block-fn c)

block-value clj

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

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.

build clj deprecated

build! clj

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

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)

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

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, to be used for consecutive blocks.

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.

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

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)

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