LÖVE

Code: Select all

local collision_data = ec:getEnterCollisionData('projectile')
local b = collision_data.collider:getObject()
(...)

Code: Select all

local all_stay_data = ec:getStayCollisionData('projectile')
for stay_index = 1, #all_stay_data do
    local collision_data = all_stay_data[stay_index]
    local b = collision_data.collider:getObject()
    (...)
end

Code: Select all

Starting...
0.0088169407157843      <-- LINKED-LIST (REMOVE MIDDLE)
0.015085826617797       <-- TABLE (REMOVE MIDDLE)
0.0037212258294996      <-- TABLE (REMOVE LAST)

0.017078480483006       <-- LINKED-LIST (ITERATE)
0.0058362494843696      <-- TABLE (ITERATE)
Finished.

Code: Select all

io.stdout:setvbuf('no')

-- Used for making DOUBLY-LINKED LISTS of nodes.
--
-- The list itself is a table that stores a reference to the first
-- and last nodes, if the list isn't empty:
-- {[1] = FIRST NODE, [2] = LAST NODE}
--
-- For maximum speed, the nodes are array-only tables in this format:
-- {[1] = VALUE, [2] = PREVIOUS NODE, [3] = NEXT NODE}
local LinkedList = {}

function LinkedList.new(self, ...)
    local newList = {
        nil, -- [1] = Reference to the first node, if any.
        nil, -- [2] = Reference to the last node, if any.
        -- Functions.
        add        = LinkedList.add,
        disconnect = LinkedList.disconnect,
        clear      = LinkedList.clear,
    }
    return newList
end
setmetatable(LinkedList, {__call = LinkedList.new})


function LinkedList.add(list, value)
    local newNode = {value, list[2], nil}
    if list[2] then
        list[2][3] = newNode
    else
        -- If there's no last node then there's no first node either, because
        -- a one-node list has the same node in both first and last places.
        list[1] = newNode
    end
    -- Set the new node as the last.
    list[2] = newNode
    return newNode
end


function LinkedList.disconnect(list, node)
    -- Reconnect the neighboring nodes, if any, so as to remove the
    -- input node from the list.
    --
    if node[2] then -- If the node has another behind it (so this isn't the first node).
        node[2][3] = node[3]
        if node[3] then -- If the node has another ahead of it (so this isn't the last node).
            node[3][2] = node[2]
        else
            list[2] = node[2]
        end
    elseif node[3] then -- If this (first node) has another in front of it.
        node[3][2] = nil
        list[1] = node[3]
    else -- Otherwise this was both the first and last node, the list is now empty.
        list[1] = nil
        list[2] = nil
    end
    -- For garbage-collection safety, remove references to other nodes.
    node[2] = nil
    node[3] = nil
end


function LinkedList.clear(list)
    local node = list[1]
    local oldNode
    while node do
        oldNode = node
        node = node[3]
        -- Remove references to other nodes.
        oldNode[2] = nil
        oldNode[3] = nil
    end
    list[1] = nil
    list[2] = nil
end


-- =====================
-- MEASURE TIMINGS
-- =====================

function deltaTime(func)
    local shortestTime = math.huge
    for x = 1, 3 do
        local startTime = love.timer.getTime()
        for y = 1, 100000 do
            func()
        end
        local endTime = love.timer.getTime() - startTime
        if endTime < shortestTime then
            shortestTime = endTime
        end
    end
    return shortestTime
end


local list = LinkedList()
local middleNode
for x = 1, 26 do
    local node = list:add(x)
    if x == 13 then
        middleNode = node
    end
end
local listDisconnect = list.disconnect
local listAdd = list.add


function workListMiddle()
    local middleValue = middleNode[1]
    listDisconnect(list, middleNode)
    middleNode = listAdd(list, middleValue)
end


function workListIterate()
    local result = 0
    local node = list[1]
    while node do
        result = result + node[1]
        node = node[3]
    end
    return result
end


local array = {}
for x = 1, 26 do
    array[x] = x
end
local tableRemove = table.remove
local tableInsert = table.insert


function workTableMiddle()
    local lastValue = array[13]
    tableRemove(array, 13)
    tableInsert(array, 13, lastValue)
end


function workTableIterate()
    local result = 0
    for x = 1, 26 do
        result = result + array[x]
    end
    return result
end


function workTableLast()
    local lastValue = array[26]
    tableRemove(array)
    tableInsert(array, lastValue)
end


print('Starting...')
love.timer.sleep(2)
print(deltaTime(workListMiddle), '<-- LINKED-LIST (REMOVE MIDDLE)')
love.timer.sleep(1)
print(deltaTime(workTableMiddle), '<-- TABLE (REMOVE MIDDLE)')
love.timer.sleep(1)
print(deltaTime(workTableLast), '<-- TABLE (REMOVE LAST)')
print()
love.timer.sleep(1)
print(deltaTime(workListIterate), '<-- LINKED-LIST (ITERATE)')
love.timer.sleep(1)
print(deltaTime(workTableIterate), '<-- TABLE (ITERATE)')
print('Finished.')


function love.keypressed(key)
    if key == 'escape' then
        love.event.quit()
    end
end