hump Helper Utilities for More Productivity

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.

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

Note that there is no guarantee that the delay will be exceeded. It is, however, guaranteed that the function will not be executed before the delay has passed.

If the function is called, it will receive itself as only parameter. This may be useful to implement the periodic behavior of Timer.addPeriodic (see the example).

The same things as with Timer.add apply.

The interpolating function func will receive the fraction (in respect to the supplied length) of time that has passed, but 1.0 at max.

Interpolator creates a function that will have to be called in love.update, which will itself execute func with the right parameters. It returns true as long as the interpolation is not yet finished or nil if the interpolation stopped as well as any parameters that the function returns.

The prototype of the functions are:

• Argument function: function arg(fraction, ...) where ... are additional arguments.
• Returned function: function inter(dt, ...) where ... are arguments that get passed to arg

The function does the same as Interpolator, except that if the passed time reaches length, the internal timer will be reset. That means that the fraction-argument of the oscillating function will loop from 0 to 1.

See the example for clarification

time = 0
circles = {}
function love.load()
    Timer.add(1, function() circles[#circles+1] = {x = 100, y = 100, r = 10} end)
    Timer.add(2, function() circles[#circles+1] = {x = 130, y = 130, r = 20} end)
    Timer.add(3, function() circles[#circles+1] = {x = 180, y = 180, r = 30} end)
    Timer.add(4, function() circles[#circles+1] = {x = 250, y = 250, r = 40} end)
    Timer.add(5, function() circles[#circles+1] = {x = 340, y = 340, r = 50} end)
    Timer.addPeriodic(1, function() time = time + 1 end)

    love.graphics.setBackgroundColor(255,255,255)
    love.graphics.setColor(0,0,0)
end

function love.update(dt)
    Timer.update(dt)
end

function love.draw()
    love.graphics.print(tostring(time), 20,20)
    for _,c in ipairs(circles) do
        love.graphics.circle('fill', c.x, c.y, c.r)
    end
end

Timer.add(1, function(func) print("foo") Timer.add(1, func) end)

function love.load()
    love.graphics.setBackgroundColor(0,0,0)
    love.graphics.setColor(0,0,0)
end

xpos = 100
fader = Interpolator(5, function(frac) love.graphics.setBackgroundColor(frac*255,frac*255,frac*255) end)
mover = Oscillator(10, function(frac) xpos = 400 + 300 * math.sin(2*math.pi*frac) end)
function love.update(dt)
    fader(dt)
    mover(dt)
end

function love.draw()
    love.graphics.circle('fill', xpos, 300, 80, 36)
end

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

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

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

Treats both vectors as vectors of the xy-plane (z-coordinate =0) and calculates a vector perpendicular on them. Because the result is perpendicular on to the input vectors, it has the form (0,0,z). The z-coordinate is returned.

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

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()

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

This is less intuitive than ringbuffer:insert(item, ...) since it appears the items are added at a random location. Use is only recommended before using ringbuffer:next() or ringbuffer:prev().

rb = Ringbuffer(1,2,5,6) -- rb = {1 ,2,5,6}, rb:get() == 1
rb:next() -- rb = {1, 2 ,5,6}, rb:get() == 2
rb:append(3,4) -- rb = {1, 2 ,5,6,3,4}, rb:get() == 2
rb:next() -- rb = {1,2, 5 ,6,3,4}, rb:get() == 5

Warning: May select the last scene when the current scene is the first scene in sequence.

Warning: May select the first scene when the current scene is the last scene in sequence.

Calls scene:draw() on currently active scene

Switches scene if current scene is finished (see scene:isFinished()).

This can be overwritten, though it is not advised to do so.

local sc = {}
-- moving and fading looks cool
sc.idea = Scene(5)
function sc.idea:draw()
    local frac = (self.time / self.length) ^ 3
    love.graphics.setColor(255,255,255,160 - frac * 160)
    love.graphics.print("Idea", 200 + frac * 30, 200)
    love.graphics.setColor(255,255,255,255 - frac * 255)
    love.graphics.print("Max Power", 300 - frac * 40, 250)
end

sc.code = Scene(5)
function sc.code:draw()
    local frac = (self.time / self.length) ^ 3
    love.graphics.setColor(255,255,255,160 - frac * 160)
    love.graphics.print("Code", 200 + frac * 30, 200)
    love.graphics.setColor(255,255,255,255 - frac * 255)
    love.graphics.print("Max Power", 300 - frac * 40, 250)
end

sc.gfx = Scene(5)
function sc.gfx:draw()
    local frac = (self.time / self.length) ^ 3
    love.graphics.setColor(255,255,255,160 - frac * 160)
    love.graphics.print("GFX", 200 + frac * 30, 200)
    love.graphics.setColor(255,255,255,255 - frac * 255)
    love.graphics.print("also Max Power", 300 - frac * 40, 250)
end

sc.endscreen = Scene(-1) -- last scene. no looping
function sc.endscreen:enter()
    self.frac = 0
end

function sc.endscreen:update(dt)
    self.frac = math.min(1, self.time / 3) -- 3 sec fade in
end

function sc.endscreen:draw()
    love.graphics.setColor(255,255,255, self.frac * 255)
    love.graphics.print("The most awesome game in history", 280, 280)
end


-- create credit sequence
credits = Sequence(sc.idea, sc.code, sc.gfx)
credits:add(sc.endscreen)


-- show and update sequence
function love.draw()
    credits:draw()
end

function love.update(dt)
    credits:update(dt)
end