Data/UI/Input.lua

-- This file is a part of Avoision.
--
-- Copyright (C) 2012 Jared Krinke.
--
-- Avoision is free software; you can redistribute it and/or
-- modify it under the terms of the GNU General Public License
-- as published by the Free Software Foundation; either version 2
-- of the License, or (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- GNU General Public License for more details.
--
-- You should have received a copy of the GNU General Public License
-- along with this program; if not, write to the Free Software
-- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

-- Raw events are string representations of unique raw events (e.g. "escape," "c")
-- Logical events are application defined (e.g. "move up")
require("Utility/List.lua")

Input = {
    joystickButtonNames = { },
    joystickAxisNames = { },
}

local maxJoysticks = 4
local maxJoystickButtons = 16
local maxJoystickAxes = 4
local joystickAxisThreshold = 0.4
local j = 1

while j <= maxJoysticks do
    local buttons = { }
    local b = 1

    while b <= maxJoystickButtons do
        local rawEvent = nil

        if j == 1 then
            rawEvent = "jb" .. b
        else
            rawEvent = "j" .. j .. "b" .. b
        end

        buttons[b] = rawEvent
        b = b + 1
    end

    local axes = { }
    local a = 0

    while a <= maxJoystickAxes do
        local axis = { }

        if j == 1 then
            axis[1] = "ja" .. a .. "+"
            axis[-1] = "ja" .. a .. "-"
        else
            axis[1] = "j" .. j .. "a" .. a .. "+"
            axis[-1] = "j" .. j .. "a" .. a .. "-"
        end

        axes[a] = axis
        a = a + 1
    end

    Input.joystickButtonNames[j] = buttons
    Input.joystickAxisNames[j] = axes
    j = j + 1
end

local function unbind(self, rawEvent, logicalEvent)
    local rawEvents = self.logicalToRaw[logicalEvent]
    local acceptable = false

    if not isNil(rawEvents) then
        -- Make sure the binding can be removed (i.e. the existing binding is not the only binding to a necessary logical event)
        local properties = self.logicalEvents[logicalEvent]

        if isNil(properties)
            or not isBoolean(properties.necessary)
            or not properties.necessary
            or rawEvents:getCount() > 1
        then
            rawEvents:remove(rawEvent)
            acceptable = true
        end
    end

    if acceptable then
        self.rawToLogical[rawEvent] = nil
    end

    return acceptable
end

local function notify(self)
    -- Notify all listeners that input bindings have been updated
    self.listeners:forEach(function(handler)
        handler()
    end)
end

function Input.translateJoystickButtonToRawEvent(joystick, button)
    local name = nil

    if joystick <= maxJoysticks and button <= maxJoystickButtons then
        name = Input.joystickButtonNames[joystick][button]
    end

    return name
end

function Input.translateJoystickAxisMoveToRawEvent(layer, joystick, axis, value)
    -- Check for previous state tables
    local joystickAxisPositions = layer.joystickAxisPositions

    if not isTable(joystickAxisPositions) then
        joystickAxisPositions = { }
        layer.joystickAxisPositions = joystickAxisPositions
    end

    local joystickAxisPosition = joystickAxisPositions[joystick]

    if not isTable(joystickAxisPosition) then
        joystickAxisPosition = { }
        layer.joystickAxisPositions[joystick] = joystickAxisPosition
    end

    -- Determine current position
    local position = 0

    if abs(value) >= joystickAxisThreshold then
        if value > 0 then
            position = 1
        else
            position = -1
        end
    end

    -- Compare to previous position
    local rawEventPressed = nil
    local rawEventReleased = nil
    local previousPosition = joystickAxisPosition[axis]

    if isNil(previousPosition) then
        previousPosition = 0
    end

    if position ~= previousPosition then
        if previousPosition ~= 0 then
            -- Previously set, but no longer set, so send a release event
            rawEventReleased = Input.joystickAxisNames[joystick][axis][previousPosition]
        end

        if position ~= 0 then
            -- Newly set; send a press event
            rawEventPressed = Input.joystickAxisNames[joystick][axis][position]
        end
    end

    joystickAxisPosition[axis] = position

    return rawEventPressed, rawEventReleased
end

function Input.new(logicalEvents, defaultRawToLogical)
    -- Mapping from a raw event to a logical event
    local input = { }

    function input.bind(self, rawEvent, logicalEvent)
        -- Remove the old binding (if one exists)
        local oldLogicalEvent = self.rawToLogical[rawEvent]
        local acceptable = true

        if not isNil(oldLogicalEvent) then
            -- Check to make sure the existing binding can be removed
            acceptable = unbind(self, rawEvent, oldLogicalEvent)
        end

        if acceptable then
            -- Insert the new binding
            self.rawToLogical[rawEvent] = logicalEvent

            if not isNil(logicalEvent) then
                -- Ensure a list of raw events is present
                local rawEvents = self.logicalToRaw[logicalEvent]

                if isNil(rawEvents) then
                    rawEvents = List.new()
                    self.logicalToRaw[logicalEvent] = rawEvents
                end

                rawEvents:add(rawEvent)
            end

            -- Notify all listeners that input bindings have been updated
            notify(self)
        end

        return acceptable
    end

    function input.unbind(self, rawEvent, logicalEvent)
        unbind(self, rawEvent, logicalEvent)

        -- Notify all listeners that input bindings have been updated
        notify(self)
    end

    function input.setupEventHandlers(self, layer)
        -- Key presses
        local defaultKeyPressed = layer.keyPressed

        layer.keyPressed = function(l, key, pressed, character)
            local logicalEvent = self.rawToLogical[key]
            local handled = false

            -- Call the logical event handler if a mapping exists
            if isString(logicalEvent) then
                handled = l:inputReceived(logicalEvent, pressed, "keyPressed", key, character)
            end

            -- If no mapping exists or the logical event was not handled, send the raw event
            if not handled and isFunction(defaultKeyPressed) then
                handled = defaultKeyPressed(l, key, pressed, character)
            end

            return handled
        end

        -- Mouse buttons
        local defaultMouseButtonPressed = layer.mouseButtonPressed

        layer.mouseButtonPressed = function(l, button, pressed, x, y)
            -- Convert mouse button to raw event
            local rawEvent = button
            local logicalEvent = self.rawToLogical[rawEvent]
            local handled = false

            if isString(logicalEvent) then
                handled = l:inputReceived(logicalEvent, pressed, "mouseButtonPressed")
            end

            if not handled and isFunction(defaultMouseButtonPressed) then
                handled = defaultMouseButtonPressed(l, button, pressed, x, y)
            end

            return handled
        end

        -- Joystick buttons
        local defaultJoystickButtonPressed = layer.joystickButtonPressed

        layer.joystickButtonPressed = function(l, joystick, button, pressed)
            local rawEvent = Input.translateJoystickButtonToRawEvent(joystick, button)
            local handled = false

            if isString(rawEvent) then
                local logicalEvent = self.rawToLogical[rawEvent]

                -- Call the logical event handler if a mapping exists
                if isString(logicalEvent) then
                    handled = l:inputReceived(logicalEvent, pressed, "joystickButtonPressed")
                end
            end

            -- If no mapping exists or the logical event was not handled, send the raw event
            if not handled and isFunction(defaultJoystickButtonPressed) then
                handled = defaultJoystickButtonPressed(l, joystick, button, character)
            end

            return handled
        end

        -- Joystick axes
        local defaultJoystickAxisMoved = layer.joystickAxisMoved

        layer.joystickAxisMoved = function(l, joystick, axis, value)
            local rawEventPressed
            local rawEventReleased
            local handledLogicalPress = false
            local handledLogicalRelease = false
            local handledRaw = false

            -- Check both possible logical events for handlers
            rawEventPressed, rawEventReleased = Input.translateJoystickAxisMoveToRawEvent(l, joystick, axis, value)

            if isString(rawEventPressed) then
                local logicalEvent = self.rawToLogical[rawEventPressed]

                if isString(logicalEvent) then
                    handledLogicalPress = l:inputReceived(logicalEvent, true, "joystickAxisMoved")
                end
            end

            if isString(rawEventReleased) then
                local logicalEvent = self.rawToLogical[rawEventReleased]

                if isString(logicalEvent) then
                    handledLogicalRelease = l:inputReceived(logicalEvent, false, "joystickAxisMoved")
                end
            end

            -- For joystick axes (which are actually stateless), always call the raw callback
            if isFunction(defaultJoystickAxisMoved) then
                handledRaw = defaultJoystickAxisMoved(l, joystick, button, character)
            end

            return handledLogicalPress or handledLogicalRelease or handledRaw
        end
    end

    function input.addListener(self, handler)
        if isFunction(handler) then
            self.listeners:add(handler)
        end
    end

    function input.getRawEvents(self, logicalEvent)
        return self.logicalToRaw[logicalEvent]
    end

    function input.getRawToLogical(self)
        return input.rawToLogical
    end

    function input.getLogicalEventProperties(self, logicalEvent)
        return input.logicalEvents[logicalEvent]
    end

    input.listeners = List.new()

    if not isNil(defaultRawToLogical) then
        input.rawToLogical = { }
        input.logicalToRaw = { }

        Table.forEach(defaultRawToLogical, function(key, value)
            input:bind(key, value)
        end)
    else
        input.rawToLogical = { }
        input.logicalToRaw = { }
    end

    input.logicalEvents = logicalEvents

    return input
end