Charity

--Read data from http and split into important data
----Amount earned
----Amount earned since last checked
----Number of Contributions
------Windows
------Mac
------Linux

--Outcomes:
----Show information on monitors
----Show Amount on Large pixel screen
----Show change amount on Large pixel screen

----Trigger Fireworks
----Trigger Honeydew Image

--Two/Distinct elements
----Server
----Client
------LargeScreen Client
------SmallScreen Client

os.loadAPI("json")

--local HUMBLE_DATA = "https://rikkuness.net/humble/humble.php"
local HUMBLE_DATA = "https://humble.pubnub.com/subscribe/6b5eeae3-796b-11df-8b2d-ef048cc31d2e/humbleyogscast/0/13874707882891360?uuid=59139447-7893-4b1e-81ff-b73fdac5f5eb&pnsdk=PubNub-JS-Web%2F3%2E5%2E4"
local TRANSMIT_CHANNEL = 88

local WAIT_TIME = 15

local PIXEL_MAP = {}

local currentAmount = 0
local prevAmount = 0

local difference = 0

local contributions = {}
contributions.windows = 0
contributions.mac = 0
contributions.linux = 0
contributions.total = function() return contributions.windows + contributions.mac + contributions.linux; end

local amounts = {}
amounts.window = 0
amounts.mac = 0
amounts.linux = 0
contributions.total = function() return currentAmount; end

local function round(n)
  if n >= 0.5 then
    return math.ceil(n)
  end
  return math.floor(n)
end

local function applyValueToN(value, n)
    n = n or 1
    if n > 1 then
        return value, applyValueToN(value, n - 1)
    end
    return value
end


local function pullEvent(eventType, time)
    eventType = eventType or false
    os.startTimer(time)
    e, p1, p2, p3, p4, p5 = os.pullEvent()
    if e == "timer" then
        return false
    elseif eventType and e == eventType then
        return e, p1, p2, p3, p4, p5
    elseif eventType == false then
        return e, p1, p2, p3, p4, p5
    end

    return false
end

local function waitForEvent(eventType)
    while true do
        e, p1, p2, p3, p4, p5 = pullEvent(eventType, 5)
        if e then
            return e, p1, p2, p3, p4, p5
        end
    end
end

local function clearEvents()
    os.queueEvent("clear")
    while true do
        e = os.pullEvent()
        if e == "clear" then
            break
        end
    end
end

local function pullData()
    os.startTimer(5);
    http.request(HUMBLE_DATA)
    while true do
        local e, url, data = os.pullEvent()
        if e == "http_success" then
            return data.readAll()
        else
            return false
        end
    end
end

local function decodeData(v)
    return json.decode(v)
end

local function getNumberedPeripherals(type, startIndex, endIndex)
    local output = {}
    local c = 1
    for i = startIndex, endIndex do
        output[c] = peripheral.wrap(type.."_"..i)
        c = c + 1
    end
    return output
end

local function getAllPeripherals(p)
    local output = {}
    local periphs = peripheral.getNames()
    for i,v in pairs(peripheral.getNames()) do
        if peripheral.getType(v) == p then
            table.insert(output, peripheral.wrap(v))
        end
    end

    return (table.getn(output) > 0) and output or false
end

local function getPeripheral(p)
    for i,v in ipairs(peripheral.getNames()) do
        print(v)
        if peripheral.getType(v,"getType") == p then
            return peripheral.wrap(v)
        end
    end
    return false
end

local function getModem()
    return getPeripheral("modem")
end

local function getMonitor()
    return getPeripheral("monitor")
end

local function newPixelCanvas(width, height)
    local output = {}
    for x = 1, width do
        output[x] = {}
        for y = 1, height do
            output[x][y] = false
        end
    end
    return output
end

local function newObject(width, height)
    local output = {}
    output.pixels = newPixelCanvas(width, height)
    output.visible = true
    output.dirty = false
    output.dirtyPixels = {}
    output.width = width
    output.height = height
    output.x = 1
    output.y = 1

    return output
end

local function newPlusSymbol(colour)
    local output = newObject(3, 4)
    --drawing the cross
    output.pixels[2][2], output.pixels[1][3],
    output.pixels[2][3], output.pixels[3][3],
    output.pixels[2][4] = applyValueToN(colour, 5)

    return output
end

local function newNumber(n, colour)
    local output = newObject(4, 5)
    if n == 0 then
        output.pixels[2][1], output.pixels[3][1],
        output.pixels[1][2], output.pixels[4][2],
        output.pixels[1][3], output.pixels[4][3],
        output.pixels[1][4], output.pixels[4][4],
        output.pixels[2][5], output.pixels[3][5] = applyValueToN(colour, 10)
    elseif n == 1 then
        output.pixels[3][1], output.pixels[2][2],
        output.pixels[3][2], output.pixels[3][3],
        output.pixels[3][4], output.pixels[2][5],
        output.pixels[3][5], output.pixels[4][5] = applyValueToN(colour, 8)
    elseif n == 2 then
        output.pixels[1][1], output.pixels[2][1],
        output.pixels[3][1], output.pixels[4][2],
        output.pixels[2][3], output.pixels[3][3],
        output.pixels[1][4], output.pixels[1][5],
        output.pixels[2][5], output.pixels[3][5],
        output.pixels[4][5] = applyValueToN(colour, 11)
    elseif n == 3 then
        output.pixels[1][1], output.pixels[2][1],
        output.pixels[3][1], output.pixels[4][2],
        output.pixels[2][3], output.pixels[3][3],
        output.pixels[4][4], output.pixels[1][5],
        output.pixels[2][5], output.pixels[3][5] = applyValueToN(colour, 10)
    elseif n == 4 then
        output.pixels[1][1], output.pixels[1][2],
        output.pixels[3][2], output.pixels[1][3],
        output.pixels[1][3], output.pixels[3][3],
        output.pixels[1][4], output.pixels[2][4],
        output.pixels[3][4], output.pixels[4][4],
        output.pixels[3][5] = applyValueToN(colour, 11)
    elseif n == 5 then
        output.pixels[1][1], output.pixels[2][1],
        output.pixels[3][1], output.pixels[4][1],
        output.pixels[1][2], output.pixels[1][3],
        output.pixels[2][3], output.pixels[3][3],
        output.pixels[4][4], output.pixels[1][5],
        output.pixels[2][5], output.pixels[3][5] = applyValueToN(colour, 12)
    elseif n == 6 then
        output.pixels[2][1], output.pixels[3][1],
        output.pixels[1][2], output.pixels[1][3],
        output.pixels[2][3], output.pixels[3][3],
        output.pixels[1][4], output.pixels[4][4],
        output.pixels[2][5], output.pixels[3][5] = applyValueToN(colour, 10)
    elseif n == 7 then
        output.pixels[1][1], output.pixels[2][1],
        output.pixels[3][1], output.pixels[4][1],
        output.pixels[4][2], output.pixels[3][3],
        output.pixels[2][4], output.pixels[2][5] = applyValueToN(colour, 8)
    elseif n == 8 then
        output.pixels[2][1], output.pixels[3][1],
        output.pixels[1][2], output.pixels[4][2],
        output.pixels[2][3], output.pixels[3][3],
        output.pixels[1][4], output.pixels[4][4],
        output.pixels[2][5], output.pixels[3][5] = applyValueToN(colour, 10)
    elseif n == 9 then
        output.pixels[2][1], output.pixels[3][1],
        output.pixels[1][2], output.pixels[4][2],
        output.pixels[2][3], output.pixels[3][3],
        output.pixels[4][3], output.pixels[4][4],
        output.pixels[2][5], output.pixels[3][5] = applyValueToN(colour, 10)
    end
    return output
end


local function newDisplayList(height, width)
    local output = {}
    output.pixels = {}
    output.children = {}
    output.dirty = false
    output.dirtyPixels = {}
    output.height = height
    output.width = width
    output.x = 0
    output.y = 0

    for x = -width, width * 2 do
        output.pixels[x] = output.pixels[x] or {}
        for y = -height, height * 2 do
            output.pixels[x][y] = 0x000000
        end
    end

    output.addChild = function(self, object)
        object.parent = self
        self:clearPixels(object.width, object.height, object.x, object.y)
        if object.visible then
            self.dirty = true
            for x = 1, object.width do
                for y = 1, object.height do
                    if object.pixels[x] and object.pixels[x][y] then
                        self.pixels[object.x + x][object.y + y - 1] = object.pixels[x][y]
                        table.insert(self.dirtyPixels, {x = x, y = y})
                    end
                end
            end
        end
    end

    output.clearPixels = function(self, width, height, x, y)
        self.dirty = true
        for x = x, width do
            self.pixels[x] = self.pixels[x] or {}
            for y = y, height do
                --print("self.pixels[x] "..self.pixels[x])
                self.pixels[x][y] = 0x000000
                table.insert(self.dirtyPixels, {x = x, y = y})
            end
        end
    end
    return output
end

local function newYogsList(height, width)
    local output = newDisplayList(height, width)

    for x = 1, width do
        output.pixels[x] = output.pixels[x] or {}
        for y = 1, height do
            output.pixels[x][y] = 0x07294E
        end
    end
    local y = 1
    output.pixels[1][y], output.pixels[3][y], output.pixels[6][y],
    output.pixels[10][y], output.pixels[11][y], output.pixels[14][y],
    output.pixels[15][y], output.pixels[19][y], output.pixels[20][y],
    output.pixels[23][y], output.pixels[27][y], output.pixels[28][y],
    output.pixels[30][y], output.pixels[31][y], output.pixels[32][y],
    output.pixels[34][y] = applyValueToN( 0xFFFFFF, 16)

    y = 2
    output.pixels[1][y], output.pixels[3][y], output.pixels[5][y],
    output.pixels[7][y], output.pixels[9][y], output.pixels[13][y],
    output.pixels[18][y], output.pixels[22][y], output.pixels[24][y],
    output.pixels[26][y], output.pixels[31][y], output.pixels[34][y] = applyValueToN( 0xDDDDDD, 12)

    y = 3
    output.pixels[2][y], output.pixels[5][y], output.pixels[7][y],
    output.pixels[9][y], output.pixels[11][y], output.pixels[14][y],
    output.pixels[15][y], output.pixels[18][y], output.pixels[22][y],
    output.pixels[23][y], output.pixels[24][y], output.pixels[27][y],
    output.pixels[28][y], output.pixels[31][y], output.pixels[34][y] = applyValueToN( 0xBBBBBB, 15)

    y = 4
    output.pixels[2][y], output.pixels[5][y], output.pixels[7][y],
    output.pixels[9][y], output.pixels[11][y], output.pixels[16][y],
    output.pixels[18][y], output.pixels[22][y], output.pixels[24][y],
    output.pixels[29][y], output.pixels[31][y] = applyValueToN( 0x999999, 11)

    y = 5
    output.pixels[2][y], output.pixels[6][y], output.pixels[10][y],
    output.pixels[14][y], output.pixels[15][y], output.pixels[19][y],
    output.pixels[20][y], output.pixels[22][y], output.pixels[24][y],
    output.pixels[27][y], output.pixels[28][y], output.pixels[31][y],
    output.pixels[34][y] = applyValueToN( 0x777777, 13)

    return output

end

local function newSLList(height, width)
    local output = newDisplayList(height, width)

    for x = 1, width do
        output.pixels[x] = output.pixels[x] or {}
        for y = 1, height do
            output.pixels[x][y] = 0x000000
        end
    end
    -- Lewis Head

-- Row 1
output.pixels[2][2] = applyValueToN( 0x392102)
output.pixels[3][2] = applyValueToN( 0x3E2006)
output.pixels[4][2] = applyValueToN( 0x381E01)
output.pixels[5][2] = applyValueToN( 0x391E00)
output.pixels[6][2] = applyValueToN( 0x361B00)
output.pixels[7][2] = applyValueToN( 0x351A00)
output.pixels[8][2] = applyValueToN( 0x391E00)
output.pixels[9][2] = applyValueToN( 0x402000)

-- Row 2
output.pixels[2][3] = applyValueToN( 0x391802)
output.pixels[3][3] = applyValueToN( 0xFCDFBD)
output.pixels[4][3] = applyValueToN( 0xFBE1C4)
output.pixels[5][3] = applyValueToN( 0xFEDBC5)
output.pixels[6][3] = applyValueToN( 0x351A00)
output.pixels[7][3] = applyValueToN( 0xF9E7C5)
output.pixels[8][3] = applyValueToN( 0x371C00)
output.pixels[9][3] = applyValueToN( 0x3C1F02)

-- Row 3
output.pixels[2][4] = applyValueToN( 0xFCE5C1)
output.pixels[3][4] = applyValueToN( 0x2C1703)
output.pixels[4][4] = applyValueToN( 0x281603)
output.pixels[5][4] = applyValueToN( 0xF8DEB8)
output.pixels[6][4] = applyValueToN( 0xFDDCC5)
output.pixels[7][4] = applyValueToN( 0x2D1A03)
output.pixels[8][4] = applyValueToN( 0x361B00)
output.pixels[9][4] = applyValueToN( 0xFFE0BE)

-- Row 4
output.pixels[2][5] = applyValueToN( 0xFFE6B9)
output.pixels[3][5] = applyValueToN( 0xFFFCFF)
output.pixels[4][5] = applyValueToN( 0x3559A7)
output.pixels[5][5] = applyValueToN( 0xF8E9B6)
output.pixels[6][5] = applyValueToN( 0xF7E9C1)
output.pixels[7][5] = applyValueToN( 0x3658A7)
output.pixels[8][5] = applyValueToN( 0xFFFCFF)
output.pixels[9][5] = applyValueToN( 0xFBDBBE)

-- Simon's Head

-- Horns
output.pixels[24][0], output.pixels[33][0] = applyValueToN( 0xB3A99D, 2)
output.pixels[24][1], output.pixels[33][1],
output.pixels[24][2], output.pixels[33][2] = applyValueToN( 0xDFD5C9, 4)

-- Row 1
output.pixels[25][1], output.pixels[26][1],
output.pixels[27][1], output.pixels[28][1],
output.pixels[29][1], output.pixels[30][1],
output.pixels[31][1], output.pixels[32][1] = applyValueToN( 0x636162, 8)

-- Row 2
output.pixels[25][2], output.pixels[32][2] = applyValueToN( 0x463C32, 2)
output.pixels[26][2], output.pixels[27][2],
output.pixels[27][2], output.pixels[27][2],
output.pixels[27][2], output.pixels[27][2] = applyValueToN( 0x25221F, 6)

-- Row 3
output.pixels[25][3], output.pixels[27][3],
output.pixels[28][3], output.pixels[29][3],
output.pixels[30][3], output.pixels[32][3] = applyValueToN( 0xE3A588, 6)
output.pixels[26][3], output.pixels[31][3] = applyValueToN( 0x4B4B4B, 2)

-- Row 4
output.pixels[25][4], output.pixels[32][4] = applyValueToN( 0xFFD8B5, 2)
output.pixels[26][4], output.pixels[31][4] = applyValueToN( 0x131313, 2)
output.pixels[27][4], output.pixels[30][4] = applyValueToN( 0xE62F09, 2)
output.pixels[28][4] = applyValueToN( 0xB2300E)
output.pixels[29][4] = applyValueToN( 0xC34616)

-- Row 5
output.pixels[25][5], output.pixels[27][5],
output.pixels[30][5], output.pixels[32][5] = applyValueToN( 0xFFD8B5, 4)
output.pixels[28][5], output.pixels[29][5] = applyValueToN( 0x4B4B4B, 2)
output.pixels[26][5], output.pixels[31][5] = applyValueToN( 0xE62F09, 2)

output.pixels[12][1], output.pixels[15][1], output.pixels[19][1], output.pixels[20][1],
output.pixels[12][2], output.pixels[15][2], output.pixels[18][2], output.pixels[21][2],
output.pixels[13][3], output.pixels[14][3], output.pixels[15][3], output.pixels[18][3],
output.pixels[15][4], output.pixels[18][4], output.pixels[21][4], output.pixels[12][5],
output.pixels[13][5], output.pixels[14][5], output.pixels[19][5], output.pixels[20][5] = applyValueToN( 0xFF3333, 20)



    return output

end

local function newPigList(height, width)
    local output = newDisplayList(height, width)

    for x = 1, width do
        output.pixels[x] = output.pixels[x] or {}
        for y = 1, height do
            output.pixels[x][y] = 0x000000
        end
    end
    local y = 1
    output.pixels[2][y], output.pixels[3][y], output.pixels[4][y],
    output.pixels[10][y] = applyValueToN( 0xFF7AE4, 4)

    output.pixels[11][y], output.pixels[12][y], output.pixels[16][y],
    output.pixels[17][y], output.pixels[18][y], output.pixels[22][y],
    output.pixels[23][y], output.pixels[24][y], output.pixels[28][y],
    output.pixels[29][y], output.pixels[30][y], output.pixels[34][y] = applyValueToN( 0xFF0000, 12)

    y = 2
    output.pixels[1][y], output.pixels[2][y], output.pixels[3][y],
    output.pixels[4][y], output.pixels[5][y], output.pixels[6][y],
    output.pixels[7][y], output.pixels[8][y], output.pixels[9][y] = applyValueToN( 0xFF7AE4, 9)

    output.pixels[10][y], output.pixels[11][y], output.pixels[12][y],
    output.pixels[16][y], output.pixels[17][y], output.pixels[18][y],
    output.pixels[22][y], output.pixels[23][y], output.pixels[24][y],
    output.pixels[28][y], output.pixels[29][y], output.pixels[30][y],
    output.pixels[34][y] = applyValueToN( 0xFF9900, 13)

    output.pixels[13][y], output.pixels[14][y], output.pixels[15][y],
    output.pixels[19][y], output.pixels[20][y], output.pixels[21][y],
    output.pixels[25][y], output.pixels[26][y], output.pixels[27][y],
    output.pixels[31][y], output.pixels[32][y], output.pixels[33][y] = applyValueToN( 0xFF0000, 12)

    y = 3
    output.pixels[2][y], output.pixels[3][y],
    output.pixels[4][y], output.pixels[5][y], output.pixels[6][y],
    output.pixels[7][y], output.pixels[8][y], output.pixels[9][y] = applyValueToN( 0xFF7AE4, 8)

    output.pixels[10][y], output.pixels[11][y], output.pixels[12][y],
    output.pixels[16][y], output.pixels[17][y], output.pixels[18][y],
    output.pixels[22][y], output.pixels[23][y], output.pixels[24][y],
    output.pixels[28][y], output.pixels[29][y], output.pixels[30][y],
    output.pixels[34][y] = applyValueToN( 0x00FF00, 13)

    output.pixels[13][y], output.pixels[14][y], output.pixels[15][y],
    output.pixels[19][y], output.pixels[20][y], output.pixels[21][y],
    output.pixels[25][y], output.pixels[26][y], output.pixels[27][y],
    output.pixels[31][y], output.pixels[32][y], output.pixels[33][y] = applyValueToN( 0xFF9900, 12)

    y = 4
    output.pixels[5][y], output.pixels[6][y],
    output.pixels[7][y], output.pixels[8][y], output.pixels[9][y] = applyValueToN( 0xFF7AE4, 5)

    output.pixels[10][y], output.pixels[11][y], output.pixels[12][y],
    output.pixels[16][y], output.pixels[17][y], output.pixels[18][y],
    output.pixels[22][y], output.pixels[23][y], output.pixels[24][y],
    output.pixels[28][y], output.pixels[29][y], output.pixels[30][y],
    output.pixels[34][y] = applyValueToN( 0x0000FF, 13)

    output.pixels[13][y], output.pixels[14][y], output.pixels[15][y],
    output.pixels[19][y], output.pixels[20][y], output.pixels[21][y],
    output.pixels[25][y], output.pixels[26][y], output.pixels[27][y],
    output.pixels[31][y], output.pixels[32][y], output.pixels[33][y] = applyValueToN( 0x00FF00, 12)

    y = 5
    output.pixels[5][y], output.pixels[9][y] = applyValueToN( 0xFF7AE4, 2)

    output.pixels[13][y], output.pixels[14][y], output.pixels[15][y],
    output.pixels[19][y], output.pixels[20][y], output.pixels[21][y],
    output.pixels[25][y], output.pixels[26][y], output.pixels[27][y],
    output.pixels[31][y], output.pixels[32][y], output.pixels[33][y] = applyValueToN( 0x0000FF, 12)

    return output

end


local function newLargeScreen(height, width, displayList)
    local output = {}
    local pixels = getNumberedPeripherals("glowstone_illuminator", 0, 169)

    output.height = height
    output.width = width
    output.pixels = {}
    output.displayList = displayList or newDisplayList(7, 36)
    output.fullRefresh = false

    for x = 1, width do
        output.pixels[x] = {}
        for y = 1, height do
            if PIXEL_MAP[x] and PIXEL_MAP[x][y] then
                output.pixels[PIXEL_MAP[x][y]] = pixels[x * y]
            else
                output.pixels[x][y] = pixels[((x - 1) * height) + y]
            end
        end
    end

    output.tick = function(self)
        if self.fullRefresh then
            self:drawAll()
            return
        end

        if self.displayList.dirty then
            for i,v in ipairs(self.displayList.dirtyPixels) do
                output.pixels[v.x][v.x].setColor(self.displayList[v.x][v.y])
            end
        end
    end

    output.drawAll = function(self)
        for x = 1, self.width do
            for y = 1, self.height do
                --sleep(1)
                if self.displayList.pixels[x + self.displayList.x] and self.displayList.pixels[x + self.displayList.x][y + self.displayList.y] then
                    output.pixels[x][y].setColor(self.displayList.pixels[x + self.displayList.x][y + self.displayList.y])
                end
            end
        end
    end
    return output
end

local function largeScreen()
    local countDisplay = newDisplayList(5, 34)
    local diffDisplay = newDisplayList(5, 34)
    local yogsList = newYogsList(5,34)
    local pigList = newPigList(5,34)
    local faceList = newSLList(5,34)
    local specialList = 0
    local blankList = newDisplayList(5,34)

    local largeMonitor = newLargeScreen(5, 34, countDisplay)

    local nextSpecial = -1
    local specialLevel = -1
    local testSpecial = false

    local firstDot = peripheral.wrap("glowstone_illuminator_170")
    local secondDot = peripheral.wrap("glowstone_illuminator_171")

    firstDot.setColor( 0x000000)
    secondDot.setColor( 0x000000)

    local time = os.clock()

    largeMonitor:drawAll()

    rs.setBundledOutput("left", colours.black)

    local forceUpdate = true

    while true do

        print("getting data!")

        local e, side, sChan, rChan, message, distance = waitForEvent("modem_message", 1)
        local data = textutils.unserialize(message)

        print("got Data!")

        prevAmount = currentAmount
        currentAmount = data.currentAmount
        difference = currentAmount - prevAmount
        contributions = data.contributions
        amounts = data.amounts

        if nextSpecial < 0 then
            nextSpecial = math.ceil(currentAmount * 0.00001)
            if nextSpecial - 0.5 > currentAmount * 0.00001 then
                nextSpecial = (nextSpecial - 0.5) * 100000
                specialLevel = 1
            elseif nextSpecial % 10 == 0 then
                specialLevel = 3
            else
                specialLevel = 2
            end

            nextSpecial = nextSpecial * 100000
            print("nextSpecial is "..nextSpecial)
        end


            --new display list, draw all the numbers to the display list

        if difference > 0  or forceUpdate then

            local currentAmountStr = tostring(currentAmount)
            local prevAmountStr = tostring(prevAmount)
            local differenceStr = tostring(difference)
            local magnitudeDif = differenceStr:len()

            local runningX = largeMonitor.width

            --print("difference: "..differenceStr)

            --print(currentAmountStr.." "..prevAmountStr)
            --print(currentAmountStr:len().." "..prevAmountStr:len())
            --print(magnitudeDif)
            --print(differenceStr)

            if currentAmountStr:len() == prevAmountStr:len() and not forceUpdate then
                for i = magnitudeDif, 0, -1 do
                    local oldC = currentAmountStr:sub(currentAmountStr:len()-i, currentAmountStr:len()-i)
                    local newC = prevAmountStr:sub(prevAmountStr:len()-i, prevAmountStr:len()-i)
                    if oldC ~= newC then
                        local newNumberObj = newNumber(tonumber(newC))
                        newNumberObj.x = largeMonitor.width - ((i + 1) * 5)
                        countDisplay:addChild(newNumberObj)
                    end
                end
            else --Clear the whole thing. Chances are every number has changed
                countDisplay = newDisplayList(7,36)
                for i = currentAmountStr:len(), 1, -1 do
                    local newNumberObj = newNumber(tonumber(currentAmountStr:sub(i,i)), 0xFFFFFF)
                    newNumberObj.x = runningX - newNumberObj.width
                    runningX = newNumberObj.x - 1
                    --print("Adding Char "..currentAmountStr:sub(i,i).." at "..newNumberObj.x.." x")
                    newNumberObj.y = 1
                    countDisplay:addChild(newNumberObj)
                end
            end
            runningX = largeMonitor.width
            if difference > 0 then
                time = os.clock()
                diffDisplay = newDisplayList(5, 34)
                diffDisplay.y = 0 - diffDisplay.height
                firstDot.setColor( 0x000000)
                secondDot.setColor( 0x000000)
                for i = differenceStr:len(), 1, -1 do
                    local newNumberObj = newNumber(tonumber(differenceStr:sub(i, i)), 0xFFFFFF)
                    newNumberObj.x = runningX - newNumberObj.width
                    runningX = newNumberObj.x - 1
                    --print("Adding Char "..differenceStr:sub(i,i).." at "..newNumberObj.x.." x")
                    diffDisplay:addChild(newNumberObj)
                    if i == 1 then
                        newNumberObj = newPlusSymbol( 0x33FF33 )
                        newNumberObj.x = runningX - newNumberObj.width
                        runningX = newNumberObj.x - 1
                        newNumberObj.y = 1
                        diffDisplay:addChild(newNumberObj)
                    end
                end

                for i = largeMonitor.displayList.y, largeMonitor.displayList.height do
                    largeMonitor:drawAll()
                    largeMonitor.displayList.y = largeMonitor.displayList.y + 1
                    sleep(0.1)
                end

                largeMonitor.displayList = diffDisplay
                fullRefresh = true
                --largeMonitor:drawAll()

                for i = diffDisplay.y, 0 do
                    largeMonitor:drawAll()
                    diffDisplay.y = diffDisplay.y + 1
                    sleep(0.1)
                end

                sleep(4)

                diffDisplay.y = diffDisplay.y - 1
                for i = diffDisplay.y, 0 - diffDisplay.height, -1 do
                    largeMonitor:drawAll()
                    diffDisplay.y = diffDisplay.y - 1
                    sleep(0.1)
                end

                largeMonitor.displayList = countDisplay
                countDisplay.y = largeMonitor.displayList.height
                for i = largeMonitor.displayList.y, 0, -1 do
                    largeMonitor:drawAll()
                    largeMonitor.displayList.y = largeMonitor.displayList.y - 1
                    sleep(0.1)
                end

                largeMonitor.displayList.y = largeMonitor.displayList.y + 1

            end

            if os.clock() - time > WAIT_TIME then

                firstDot.setColor( 0x000000)
                secondDot.setColor( 0x000000)

                rand = math.random(100)

                if rand > 66 then

                    for i = largeMonitor.displayList.y, largeMonitor.displayList.height do
                        largeMonitor:drawAll()
                        largeMonitor.displayList.y = largeMonitor.displayList.y + 1
                        sleep(0.1)
                    end

                    largeMonitor.displayList = yogsList
                    yogsList.y = 0 - yogsList.height
                    rs.setBundledOutput("left", 0)

                    for i = yogsList.y, 0 do
                        largeMonitor:drawAll()
                        yogsList.y = yogsList.y + 1
                        sleep(0.1)
                    end

                    sleep(5)

                    for i = yogsList.y, yogsList.height do
                        largeMonitor:drawAll()
                        yogsList.y = yogsList.y + 1
                        sleep(0.1)
                    end

                    largeMonitor.displayList = countDisplay
                    largeMonitor.displayList.y = 0 - countDisplay.height

                    for i = largeMonitor.displayList.y, -1 do
                        largeMonitor:drawAll()
                        largeMonitor.displayList.y = largeMonitor.displayList.y + 1
                        sleep(0.1)
                    end
                elseif rand > 33 then

                    for i = largeMonitor.displayList.y, largeMonitor.displayList.height do
                        largeMonitor:drawAll()
                        largeMonitor.displayList.y = largeMonitor.displayList.y + 1
                        sleep(0.1)
                    end

                    largeMonitor.displayList = pigList
                    pigList.x = 0 - pigList.width
                    rs.setBundledOutput("left", 0)

                    for i = pigList.x, pigList.width do
                        largeMonitor:drawAll()
                        pigList.x = pigList.x + 1
                        sleep(0.1)
                    end

                    largeMonitor.displayList = countDisplay
                    largeMonitor.displayList.y = 0 - countDisplay.height

                    for i = largeMonitor.displayList.y, -1 do
                        largeMonitor:drawAll()
                        largeMonitor.displayList.y = largeMonitor.displayList.y + 1
                        sleep(0.1)
                    end
                else
                    rs.setBundledOutput("left", 0)
                    for i = largeMonitor.displayList.y, largeMonitor.displayList.height do
                    largeMonitor:drawAll()
                    largeMonitor.displayList.y = largeMonitor.displayList.y + 1
                    sleep(0.1)
                    end

                    largeMonitor.displayList = faceList
                    fullRefresh = true
                    faceList.y = 0 - faceList.height
                    --largeMonitor:drawAll()

                    for i = faceList.y, 0 do
                        largeMonitor:drawAll()
                        faceList.y = faceList.y + 1
                        sleep(0.1)
                    end

                    sleep(4)

                    faceList.y = faceList.y - 1
                    for i = faceList.y, 0 - faceList.height, -1 do
                        largeMonitor:drawAll()
                        faceList.y = faceList.y - 1
                        sleep(0.1)
                    end

                    largeMonitor.displayList = countDisplay
                    countDisplay.y = largeMonitor.displayList.height
                    for i = largeMonitor.displayList.y, 0, -1 do
                        largeMonitor:drawAll()
                        largeMonitor.displayList.y = largeMonitor.displayList.y - 1
                        sleep(0.1)
                    end

                    largeMonitor.displayList.y = largeMonitor.displayList.y + 1

                end


                rs.setBundledOutput("left", colours.black)

                time = os.clock()

            end

            if nextSpecial <= currentAmount or testSpecial then

                specialList = newDisplayList(7,36)
                runningX = largeMonitor.width

                for i = tostring(nextSpecial):len(), 1, -1 do
                    local newNumberObj = newNumber(tonumber(tostring(nextSpecial):sub(i,i)), 0xFFFFFF)
                    newNumberObj.x = runningX - newNumberObj.width
                    runningX = newNumberObj.x - 1
                    --print("Adding Char "..currentAmountStr:sub(i,i).." at "..newNumberObj.x.." x")
                    newNumberObj.y = 1
                    specialList:addChild(newNumberObj)
                end

                for i = largeMonitor.displayList.y, largeMonitor.displayList.height do
                    largeMonitor:drawAll()
                    largeMonitor.displayList.y = largeMonitor.displayList.y + 1
                    sleep(0.1)
                end

                largeMonitor.displayList = specialList
                specialList.y = 0 - specialList.height

                for i = specialList.y, 0 do
                    largeMonitor:drawAll()
                    specialList.y = specialList.y + 1
                    sleep(0.1)
                end

                specialList.y = specialList.y - 1

                if specialLevel > 2 then
                    rs.setBundledOutput("left", colours.red)
                    largeMonitor.displayList = blankList
                    largeMonitor:drawAll()
                    sleep(0.5)
                    rs.setBundledOutput("left", 0)
                    largeMonitor.displayList = specialList
                    largeMonitor:drawAll()
                    sleep(0.5)
                    rs.setBundledOutput("left", colours.red)
                    largeMonitor.displayList = blankList
                    largeMonitor:drawAll()
                    sleep(0.5)
                    rs.setBundledOutput("left", 0)
                    largeMonitor.displayList = specialList
                    largeMonitor:drawAll()
                    sleep(0.5)
                    rs.setBundledOutput("left", colours.red)
                    largeMonitor.displayList = blankList
                    largeMonitor:drawAll()
                    sleep(0.5)
                    largeMonitor.displayList = specialList
                    largeMonitor.drawAll()
                elseif specialLevel > 1 then
                    rs.setBundledOutput("left", colours.green)
                    largeMonitor.displayList = blankList
                    largeMonitor:drawAll()
                    sleep(0.5)
                    rs.setBundledOutput("left", 0)
                    largeMonitor.displayList = specialList
                    largeMonitor:drawAll()
                    sleep(0.5)
                    rs.setBundledOutput("left", colours.green)
                    largeMonitor.displayList = blankList
                    largeMonitor:drawAll()
                    sleep(0.5)
                    rs.setBundledOutput("left", 0)
                    largeMonitor.displayList = specialList
                    largeMonitor:drawAll()
                    sleep(0.5)
                    rs.setBundledOutput("left", colours.green)
                    largeMonitor.displayList = blankList
                    largeMonitor:drawAll()
                    sleep(0.5)
                    largeMonitor.displayList = specialList
                    largeMonitor:drawAll()
                else
                    rs.setBundledOutput("left", colours.blue)
                    largeMonitor.displayList = blankList
                    largeMonitor:drawAll()
                    sleep(0.5)
                    rs.setBundledOutput("left", 0)
                    largeMonitor.displayList = specialList
                    largeMonitor:drawAll()
                    sleep(0.5)
                    rs.setBundledOutput("left", colours.blue)
                    largeMonitor.displayList = blankList
                    largeMonitor:drawAll()
                    sleep(0.5)
                    rs.setBundledOutput("left", 0)
                    largeMonitor.displayList = specialList
                    largeMonitor:drawAll()
                    sleep(0.5)
                    rs.setBundledOutput("left", colours.blue)
                    largeMonitor.displayList = blankList
                    largeMonitor:drawAll()
                    sleep(0.5)
                    largeMonitor.displayList = specialList
                    largeMonitor:drawAll()
                end

                for i = specialList.y, specialList.height do
                    largeMonitor:drawAll()
                    yogsList.y = yogsList.y + 1
                    sleep(0.1)
                end

                largeMonitor.displayList = countDisplay
                largeMonitor.displayList.y = 0 - countDisplay.height

                for i = largeMonitor.displayList.y, -1 do
                    largeMonitor:drawAll()
                    largeMonitor.displayList.y = largeMonitor.displayList.y + 1
                    sleep(0.1)
                end

                nextSpecial = -1

                rs.setBundledOutput("left", colours.black)

            end

            largeMonitor.displayList = countDisplay
            fullRefresh = true
            largeMonitor:drawAll()

            if currentAmount >= 1000 then
                firstDot.setColor( 0xFFFFFF)
            else
                firstDot.setColor( 0x000000)
            end

            if currentAmount >= 1000000 then
                secondDot.setColor( 0xFFFFFF)
            else
                secondDot.setColor( 0x000000)
            end

            --forceUpdate = false
        end
    end
end

local function smallScreen()

    monitor.setTextScale(1)
    local screenImage = paintutils.loadImage("screen")

    while true do

        local e, side, sChan, rChan, message, distance = pull("modem_message", 1)
        print("message: "..message)
        local data = textutils.unserialize(message)

        prevAmount = data.prevAmount
        currentAmount = data.currentAmount
        difference = data.difference
        contributions = data.contributions
        amounts = data.amounts
    end
end

local function clientMain()
    monitor = getMonitor()
    modem = peripheral.wrap("bottom")

    modem.open(TRANSMIT_CHANNEL)

    clearEvents() --Clear out the event list so that it's clean and ready to recieve messages
    sleep(0.5)

    term.clear()
    print("Large Screen?")
    local choice = read()
    if choice:sub(1,1):lower() == "y" then
        largeScreen()
    else
        smallScreen()
    end

    --sort out logic for different clients
end

local function serverMain()
    local newData

    while true do
        oldData = newData or oldData
        print("Getting Data")
        local newData = pullData()

        --print(textutils.serialize(newData))
        if newData then
            print("newData!")
            newData = decodeData(newData)
            newData = newData[1][1]
            prevAmount = currentAmount
            currentAmount = round(newData.stats.rawtotal)
            difference = currentAmount - prevAmount
            contributions = newData.stats.numberofcontributions
            amounts = newData.stats.rawplatformtotals
        else
            print("old Data!")
        end
            print(currentAmount)
            --print(difference)

        --local data =
        if newData or oldData then
            modem.transmit(88, 1, textutils.serialize({prevAmount = prevAmount, currentAmount = currentAmount, difference = difference, contributions = contributions, amounts = amounts}))
        else
            print("No Data!")
        end

        sleep(5)
    end
end

local function main()
    modem = getModem()
    --am I a client or a server?
    term.clear()
    print("Client or Server?")
    local choice = read()
    if choice:sub(1,1):lower() == "s" then
        --I'm a server
        serverMain()
    else
        --I'm a client
        clientMain()
    end
end

main()