hump Helper Utilities for More Productivity

function vector(x,y)^ top Creates a new vector. Element access with v.x and v.y.

Parameters:	[number]x:	x coordinate
	[number]y:	y coordinate
Returns:	the vector

function isvector(v)^ top Tests for vector type.

Parameters:	v:	variable to test
Returns:	true if v is a vector

function vector:clone()^ top Clones a vector. Use when you do not want to create references.

Returns:	New vector with the same coordinates.

function vector:unpack()^ top Unpacks the vector.

Returns:	the coordinate tuple x, y
Example:
v = vector(1,2) print(v:unpack()) -- prints "1 2"

Operators^ top

Arithmetic (+, -, *, /) and comparative operators (==, <=, <) are defined:

• + and - only work on vectors. - is also the unary minus (e.g. print(-vector(1,2)) -- prints (-1,-2))
• a * b works on vectors and numbers:
  • If a is a number and b is a vector (or vice versa), the result the scalar multiplication.
  • If a and b both are vectors, then the result is the dot product.
• a / b is only defined for a being a vector and b being a number. Same as a * 1/b.

<= and < sort lexically, i.e. a < b is true if it holds: a.x < b.x or a.y < b.y if a.x == b.x

function vector:permul(other)^ top Perform element-wise multiplication, e.g. (2,3) x (3,4) = (6,12)

function vector:len()^ top Get length of vector.

function vector:len2()^ top Get squared length.

function vector:dist(other)^ top Get distance to other vector.

Example:
a,b = vector(0,1), vector(1,0) print(a:dist(b)) -- prints 1.4142135623731

function vector:normalized()^ top Get normalized vector. The original vector remains unchanged.

function vector:normalize_inplace()^ top Normalize vector and return it.

Warning: This will change the state of all references to this vector.

function vector:rotated(phi)^ top Get rotated vector. The original vector remains unchanged.

Parameters:	[number]phi:	Rotation angle in radians.
Sketch:

function vector:rotate_inplace(phi)^ top Rotate the vector and return it.

Warning: This will change the state of all references to this vector.

function vector:perpendicular()^ top Get vector rotated by 90° clockwise, e.g. the vector (0,1) results in (1,0).

Sketch:

function vector:projectOn(v)^ top Project this vector onto another one, e.g. (2,2) projected onto (1,0) results in (2,0).

Parameters:	[vector]v	Vector to project onto
Returns:	Vector with direction of v and length according to projection.
Sketch:

function Class(constructor)^ top Creates a new unnamed class.

Parameters:	[optional function]constructor	A function used to construct the class. The first parameter of this function is the object, the others are parameters given upon construction.
Returns:	the new class
Example
Feline = Class(function(self, size, weight) self.size = size self.weight = weight end) function Feline:stats() return string.format("size: %.02f, weight %.02f", self.size, self.weight) end garfield = Feline(.7, 45) felix = Feline(.8, 12) print("Garfield: " .. garfield:stats(), "Felix: " .. felix:stats())

function Class{name = name, constructor}^ top Create a named class, i.e. define a __tostring metamethod. Parameters are the same as above. Great for debugging. Both name and constructor can be omitted (but why would you want to?)

Example:
Feline = Class{name = "Feline", function(self, size, weight) self.size = size self.weight = weight end} print(Feline) -- prints 'Feline'

function Interface(name)^ top Shortcut to Class{name = name}, i.e. a possibly named class without constructor.

function Inherit(class, super, ...)^ top Add functions of super to class. Multiple interfaces can be defined.

super's constructor can be accessed via super.construct(self). See example below.

Everybody loves cats!^ top

Feline = Class{name = "Feline", function(self, size, weight)
self.size = size self.weight = weight
end}

function Feline:stats()
return string.format("size: %.02f, weight %.02f", self.size, self.weight)
end

function Feline:speak() print("meow") end


Cat = Class{name = "Cat", function(self, name, size, weight)
Feline.construct(self, size, weight)
self.name = name
end}
Inherit(Cat, Feline)

function Cat:stats()
return string.format("name: %s, %s", self.name, Feline.stats(self))
end


Tiger = Class{name = "tiger", function(self, size, weight)
Feline.construct(self, size, weight)
end}
Inherit(Tiger, Feline)

function Tiger:speak() print("ROAR!") end

felix = Cat("Felix", .8, 12)
hobbes = Tiger(2.2, 68)

print(felix:stats(), hobbes:stats())
felix:speak()
hobbes:speak()

Nothing is perfect^ top

Be careful when using metamethods like __add or __mul: When subclass inherits those methods from a superclass, but does not overwrite them, the result of the operation may be of the type superclass. Consider the following:

A = Class(function(self, x) self.x = x end)
function A:__add(other) return A(self.x + other.x) end
function A:print() print("A:", self.x) end

B = Class(function(self, x, y) A.construct(self, x) self.y = y end)
Inherit(B, A)
function B:print() print("B:", self.x, self.y) end
function B:foo() print("foo") end

one, two = B(1,2), B(3,4)
result = one + two
result:print()  -- prints "A:    4"
result:foo()    -- error: method does not exist

function Camera(pos, zoom, rotation)^ top Create a new camera with position pos, zoom zoom and rotation rotation.

Parameters:	[optional vector]pos:	Initial position of the camera. Defaults to (0,0).
	[optional number]zoom:	Initial zoom. Defaults to 1.
	[optional number]rotation:	Initial rotation in radians. Defaults to 0.
Returns:	a new camera object

function camera:rotate(phi)^ top Rotate camera by phi radians. Same as camera.rot = camera.rot + phi.

function camera:translate(t)^ top Translate (move) camera by vector t. Same as camera.pos = camera.pos + t.

function camera:draw(func)^ top Apply camera transformation to drawings in function func. Shortcut to camera:apply() and camera:deapply() (see below).

Example
cam:draw(function() love.graphics.rectangle('fill', -100,-100, 200,200) end)

function camera:apply()^ top Apply camera transformations to every drawing operation until the next camera:deapply().

function camera:deapply()^ top Revert camera transformations for the rest of the drawing operations.

Example:	(equivalent to the cam:draw() example above)
camera:apply() love.graphics.rectangle('fill', -100,-100, 200,200) camera:deapply()

function camera:transform(p)^ top Transform vector p from camera coordinates to world coordinates. You probably won't need this, but it is the basis to camera:mousepos().

function camera:mousepos()^ top Get mouse position in world coordinates, i.e. the position the users mouse is currently pointing at when camera transformations are applied. Use this for any mouse interaction with transformed objects in your game.

function Gamestate.new()^ top Create a new gamestate.

Returns:	The new (but empty) gamestate object.

function Gamestate.switch(to, ...)^ top Switch the gamestate.

Calls leave() on the currently active gamestate.

Calls enter(current, ...) on the target gamestate, where current is the gamestate before the switch and ... are the additionals arguments given to Gamestate.switch.

Parameters:	[gamestate]to:	target gamestate.
	...:	additional arguments to pass
Returns:	the result of to:enter(current, ...)

function Gamestate.update(dt)^ top Calls update(dt) on current gamestate.

function Gamestate.draw()^ top Calls draw() on current gamestate.

function Gamestate.keypressed(key, unicode)^ top Calls keypressed(key, unicode) on current gamestate.

function Gamestate.keyreleased(key)^ top Calls keyreleased(key) on current gamestate.

function Gamestate.mousereleased(x,y,btn)^ top Calls mousereleased(x,y,btn) on the current gamestate.

function Gamestate.registerEvents()^ top Registers all above events so you don't need to call then in your love.* routines.

It is an error to call this anywhere else than love.load(), since it overwrites the callbacks. Dont worry though, your callbacks will still be executed.