NetherPVP devices/cell

--[[

    Nether PVP Arena
    Cell device

--]]

game = game or {}

local Cell = common.newClass(mcnet.device.Servant, {
    -- Device
    deviceType = "netherpvp:cell",
    -- Servant
    registerServerMessage = "netherpvp:registerCell",
    registeredServerMessage = "netherpvp:registeredCell",
    serverType = "netherpvp:master",
    -- Game configuration
    winTimeout = 0,
    -- Redstone
    getColorSide = nil,
    setColorSide = nil,
    setColorBit = 0,
    setColorTimeout = 0.5,
    openSide = nil,
    openBit = 0,
    leverSide = nil,
    leverBit = 0,
    resetLeverSide = nil,
    resetLeverBit = 0
})
game.Cell = Cell

-- Constructor
function Cell:init()
    mcnet.device.Servant.init(self)

    -- Address
    self.address = mcnet.address.new{
        localPart = self.name,
        domainPart = self.domain
    }

    -- Reset
    self:resetGame()

    self:on("redstone", self.handleLever, self)
    self:on("timer", self.handleTimer, self)

    self:addMessageHandler{
        [game.msg.getColor] = self.handleGetColor,
        [game.msg.newRound] = self.handleNewRound,
        [game.msg.startRound] = self.startRound,
        [game.msg.stopRound] = self.stopRound
    }
end

function Cell:checkServer(deviceType, deviceAddress)
    return deviceType == self.serverType and deviceAddress.domainPart == self.domain
end

function Cell:stop()
    -- Reset game
    self:resetGame()
    -- Stop device
    mcnet.device.Servant.stop(self)
end

--[[

    Utilities

--]]

-- Post message to master
function Cell:post(msg)
    if not self:isConnected() then
        self:trigger("error", "cellDisconnected", "Cell not connected to master")
        return false
    end

    -- Sender address
    msg.from = self.address

    -- Send message
    local result = self:send(self.serverId, msg)
    if not result then
        self:trigger("error", "postMessageFailed", "Could not post message")
    end
    return result
end

--[[

    Color

--]]

function Cell:getColor()
    return rs.getBundledInput(self.getColorSide)
end

function Cell:rsCombine(side, color)
    return rs.setBundledOutput(side, colors.combine(rs.getBundledOutput(side), color))
end

function Cell:rsSubtract(side, color)
    return rs.setBundledOutput(side, colors.subtract(rs.getBundledOutput(side), color))
end

function Cell:rsPulse(side, color, duration)
    self:rsCombine(side, color)
    os.sleep(duration)
    self:rsSubtract(side, color)
    os.sleep(duration)
end

function Cell:setColor(color)
    print("setColor to ", color)
    local oldColor = self:getColor()

    while self:getColor() ~= color do
        print("  current: ", self:getColor())

        -- Cycle color
        self:rsPulse(self.setColorSide, self.setColorBit, self.setColorTimeout)

        -- Prevent infinite loops on bad color input
        if rs.testBundledInput(self.getColorSide, oldColor) then
            return false
        end
    end
    print("setColor end")

    return true
end

-- Report color
function Cell:handleGetColor(senderId, msg)
    local color = self:getColor()
    self:trigger("getColor", color)

    -- Reply color to master
    return self:post(mcnet.message.new{
        type = game.msg.notifyColor,
        data = color
    })
end

--[[

    Cell opening

--]]

function Cell:openCell()
    self:rsSubtract(self.openSide, self.openBit)
end

function Cell:closeCell()
    self:rsCombine(self.openSide, self.openBit)
end

--[[

    Game

]]--

function Cell:resetGame()
    -- Stop round
    self:stopRound()
    -- Clear lever reset
    self:rsSubtract(self.resetLeverSide, self.resetLeverBit)
end

--[[

    Rounds

]]--

-- Round started
function Cell:startRound()
    self:trigger("startRound")
    -- Clear lever reset
    self:rsSubtract(self.resetLeverSide, self.resetLeverBit)
    -- Open cell
    self:openCell()
end

-- Round stopped
function Cell:stopRound()
    self:trigger("stopRound")
    -- Stop win timer
    self:stopWinTimer()
    -- Close cell
    self:closeCell()
end

-- Player wins round
function Cell:winRound()
    self:trigger("winRound")

    -- Stop round and reset lever
    self:stopRound()
    self:rsCombine(self.resetLeverSide, self.resetLeverBit)

    -- Report win to master
    self:post(mcnet.message.new{
        type = game.msg.notifyWin,
        data = self:getColor()
    })
end

-- New round starting
function Cell:handleNewRound(senderId, msg)
    self:trigger("newRound")

    -- Stop round and reset lever
    self:stopRound()
    self:rsCombine(self.resetLeverSide, self.resetLeverBit)

    -- Set color
    self:setColor(tonumber(msg.data))

    -- Report as ready to master
    self:post(mcnet.message.new{
        type = game.msg.notifyReady,
        data = self:getColor()
    })
end

--[[

    Winning round

--]]

function Cell:startWinTimer()
    self:trigger("startWinning")

    -- Start win timer
    self.winTimer = os.startTimer(self.winTimeout)
end

function Cell:stopWinTimer()
    self:trigger("stopWinning")

    -- Remove reference to win timer
    self.winTimer = nil
end

function Cell:isWinTimerRunning()
    return self.winTimer ~= nil
end

function Cell:handleLever()
    -- Check if lever is activated
    if rs.testBundledInput(self.leverSide, self.leverBit) then
        -- Start win timer if not already running
        if not self:isWinTimerRunning() then
            self:startWinTimer()
        end
    else
        -- Stop win timer
        self:stopWinTimer()
    end
end

function Cell:handleTimer(timer)
    if timer == self.winTimer then
        -- Win timer ran out, player wins round
        self:winRound()
    end
end