quip.util — com.kimbsy/quip 4.0.0

Miscellaneous utility functions.

Vector math functions for position/rotation/velocity calculations.

Geometric collision detection predicates.

Misc utilities.

background clj

black clj

blue clj

bold-font clj

bold-italic-font clj

coarse-polys-collide? clj

(coarse-polys-collide? poly-a poly-b)

Predicate to determine if two polygons possibly collide.

Checks if the minimum rectangles containing the polygons overlap. If they do we should use fine-polys-collide? to check properly.

coarse-pos-in-poly? clj

(coarse-pos-in-poly? [x y] poly)

Predicate to determine if a point is possibly inside a polygon.

Checks if the point is contanied by the minimum rectangle containing the polygon. If the point is inside this rectangle we should use fine-pos-in-poly? to check properly.

darken clj

(darken [_r _g _b a :as color])

Darken a colour by 30, preserving alpha component if present.

default-font clj

default-text-size clj

direction-vector clj

(direction-vector r)

Calculate the unit direction vector based on the rotation angle.

equal-pos? clj

(equal-pos? pos-a pos-b)

Predicate to check if two positions are equal.

fill clj

fine-polys-collide? clj

(fine-polys-collide? poly-a poly-b)

Predicate to determine if two polygons overlap.

We first check if there are any points shared by the polygons, then we check if any of the lines intersect.

If no lines intersect it is still possible that one polygon is fully containing the other. In this case one polygon will contain all the points of the other. So we can just check if the first point of poly-a is contained in poly-b or vice versa.

fine-pos-in-poly? clj

(fine-pos-in-poly? pos poly)

Uses ray casting to check if a polygon encloses a pos.

We construct a line starting at our point and count how many of the polygon lines it intersects, an odd number of intersections means the point is inside the polygon.

Our line should be infinite, but in practice any large number will suffice.

gray clj

green clj

grey clj

hex->rgb clj

(hex->rgb hex-string)

invert clj

(invert v)

Multiply each component of the vector by -1.

Represents a rotation of 180 degrees.

italic-bold-font clj

italic-font clj

large-text-size clj

lighten clj

(lighten [_r _g _b a :as color])

Lighten a colour by 30, preserving alpha component if present.

lines-intersect? clj

(lines-intersect? [[x1 y1 :as p1] [x2 y2 :as p2] :as l1]
                  [[x3 y3 :as p3] [x4 y4 :as p4] :as l2])

Predicate to determine if two lines intersect.

We have decided that zero-length lines do not intersect as the complexity in determining their intersection is not worth the performance hit.

line a: (x1, y1) -> (x2, y2) line b: (x3, y3) -> (x4, y4)

lines intersect iff: 0.0 <= numerator-t/denominator-t <= 1.0 and 0.0 <= numerator-u/denominator-u <= 1.0

We can just assert that the fraction is bottom-heavy.

magnitude clj

(magnitude v)

Calculate the length of a vector.

make-pos clj

(make-pos [x-factor y-factor])

Create an [x y] vector based on the supplied factors and the current game width and height.

ms->frames clj

(ms->frames ms)

(ms->frames ms frame-rate)

Determines the expected number of frames to be processed in ms milliseconds. Useful for defining tweens or delays based on time instead of frame count directly.

Optionally takes a specific framerate (in case you want to use the :average-fps in the game state for a more stable result).

Minimum returned value is 1.

normalize clj

(normalize v)

Calculate the unit vector of a given vector.

We calculate the reciprocal of the magnitude of the vector and multiply the components by this factor to avoid multiple division operations.

orthogonals clj

(orthogonals [x y])

Calculate the two orthogonal vectors to a given 2D vector.

Y axis is inverted so this returns [90-degrees-right-vector 90-degrees-left-vector]

poly-lines clj

(poly-lines poly)

Construct the lines that make up a polygon from its points.

poly-w-h clj

(poly-w-h poly)

polys-collide? clj

(polys-collide? poly-a poly-b)

Predicate to check if two polygons overlap.

The fine-polys-collide? predicate is expensive so we only do it if the cheaper coarse-polys-collide? says this is a possible collision.

pos->ray clj

(pos->ray [x y])

Creates an arbitrarily long line starting at the specified pos.

When doing poly->point collision detection a point lying on a horizontal edge of a poly would cause a division by zero if we used a horizontal ray.

This would be handled, but would not count as a collision so we increment y to make it much less likely that the intersecting lines are parallel.

pos-in-poly? clj

(pos-in-poly? pos poly)

Predicate to check if a pos is inside a polygon.

The fine-pos-in-poly? predicate is expensive so we only do it if the cheaper coarse-pos-in-poly? says this is a possible collision.

pos-in-rect? clj

(pos-in-rect? [ax ay] [bx1 by1 bx2 by2])

Predicate to check if a position is inside a rectangle.

rects-overlap? clj

(rects-overlap? [ax1 ay1 ax2 ay2] [bx1 by1 bx2 by2])

Predicate to determine if two rectangles overlap.

red clj

rotate-vector clj

(rotate-vector [x y :as v] r)

Rotate a vector about the origin by r degrees.

Checks first for r representing an integer number of rotations, in with case the vector will be unchanged.

rotation-angle clj

(rotation-angle [x y])

Calculate the rotation angle of a vector.

small-text-size clj

squared-magnitude clj

(squared-magnitude [x y z])

Sum the squares of the components of a vector.

The if check on z is a lot faster than doing an apply or reduce across the vector.

stroke clj

title-text-size clj

unit-vector clj

(unit-vector v)

Calculate the unit vector of a given vector.

v< clj

(v< a b)

Determine if the magnitude of a vector a is less than the magnitude of vector b.

We can just compare the component squares to avoid the costly sqrt operations.

v<= clj

(v<= a b)

Determine if the magnitude of a vector a is less than or equal to the magnitude of vector b.

We can just compare the component squares to avoid the costly sqrt operations.

white clj

wrap-trans-rot clj

(wrap-trans-rot [x y] r f)

Perform a translation, a rotation, invoke the supplied function (probably drawing a sprite, then reset the transform matrix to the identity.

zero-vector? clj

(zero-vector? v)

Predicate to check if a vector has length 0.