Lee

require "struct"
dofile("table.lua")

function Class(members)
    members = members or {}
    local mt = {
        __metatable = members;
        __index     = members;
    }
    local function new(_, init)
        return setmetatable(init or {}, mt)
    end
    local function copy(obj, ...)
        local newobj = obj:new(unpack(arg))
        for n,v in pairs(obj) do newobj[n] = v end
        return newobj
    end
    members.new  = members.new  or new
    members.copy = members.copy or copy
    return mt
end


--[[Class]] Reader = { --
    new = function(self, stream)
        local __members__ = {
                stream = stream
        }
        local __meta__ = {__metatable = self, __index = self}
        local _return_ = setmetatable(__members__, __meta__)

        return _return_
    end
    ,
    line = function(self)
        return ReadLine(self.stream):trim()
    end
    ,
    int = function(self)
        return ReadInt(self.stream)
    end
    ,
    short = function(self)
        return ReadShort(self.stream)
    end
    ,
    str = function(self, ln)
        return ReadString(self.stream, ln)
    end
    ,
    byte = function(self)
        return ReadByte(self.stream)
    end
}
Class(Reader) --[[Class]]--


--[[Class]] Map = { --
    header = "Unreal Software's Counter-Strike 2D Map File",
    maxheader = "Unreal Software's Counter-Strike 2D Map File (max)",
    mapcheck = "ed.erawtfoslaernu",
    new = function(self, file)
        local timeit = os.clock()
        local __members__ = {

                file = file,
                data = "",
                reader = nil,
                metadata = {},

                tiles = {},
                modes = {},
                entities = {},
                collisions = {},
                gradient = {},
                antigradient = {},
        }
        local __meta__ = {__metatable = self, __index = self}
        local _return_ = setmetatable(__members__, __meta__)

        _return_:get_meta()
        _return_:get_tiles()
        _return_:get_entities()
        _return_.metadata.loadtime = (os.clock() - timeit)
        return _return_
    end
    ,
    get_meta = function(self)
        local _handle_ = io.open(self.file, "rb")

        self.data = _handle_:read(100)
        while true do
            local block = _handle_:read(100)
            if not block then break end
            self.data = self.data..block
        end

        _handle_:close()

        self.reader = Reader:new(self.data)

        local m = self.metadata
        local r = self.reader

        --Header Check
        m.header = r:line():trim()
        if m.header == Map.header then
            for i = 1, 9 do r:byte() end
            for i = 1, 10 do r:int() end
            for i = 1, 10 do r:line() end
            m.version = "legacy"
        elseif m.header == Map.maxheader then
            for i = 1, 10 do r:line() end
            m.version = "max"
        else
            return "MapHeader is incorrect"
        end

        --Coded Information
        m.code = r:line()
        m.tileset = r:line()
        m.loaded = r:byte()
        m.mx = r:int()
        m.my = r:int()
        m.background = r:line()
        m.backgroundx = r:int()
        m.backgroundy = r:int()
        m.red = r:byte()
        m.green = r:byte()
        m.blue = r:byte()

        --Map Check
        m.check = r:line():trim()
        if m.check ~= Map.mapcheck then return "MapCheck is incorrect" end

        m.tilemode = {}
        for i=1, m.loaded + 1 do
            table.insert(m.tilemode, r:byte())
        end
    end
    ,
    get_tiles = function(self)
        local t_ = self.tiles
        local m_ = self.modes
        local m = self.metadata
        local r = self.reader
        local c_ = self.collisions
        local stream = s_get(r.stream):sub(1,(m.mx+1)*(m.my+1))
        s_update(r.stream, (m.mx+1)*(m.my+1))
        for x=1, m.mx+1 do
            for y=1, m.my+1 do
                local _b_ = stream:byte((x-1)*(m.my+1)+y)
                if _b_ > m.loaded then _b_ = 0 end
                local _m_ = m.tilemode[_b_+1]

                if not t_[x] then t_[x] = {} end
                if not m_[x] then m_[x] = {} end
                if not c_[x] then c_[x] = {} end

                t_[x][y] = _b_
                m_[x][y] = _m_

                if isIn(_m_, {1,2,3,4}) then
                    c_[x][y] = _m_
                    table.insert(self.gradient, {x,y,_m_})
                else
                    c_[x][y] = 0
                    table.insert(self.antigradient, {x,y,_m_})
                end
            end
        end

    end
    ,
    get_entities = function(self)
        local m = self.metadata
        local e = self.entities
        local r = self.reader

        m.entities = r:int()

        for i = 1, m.entities do
            local name  = r:line()
            local type  = r:byte()
            local x     = r:int()
            local y     = r:int()
            local trig  = r:line()

            local _args_ = {}
            for _n_ = 1, 10 do
                table.insert(_args_, {r:int(), r:line()})
            end

            table.insert(e, {name = name, type = type, x = x, y = y, trigger = trig, args = _args_})
        end
    end
    ,
    mapogram = function (self)
        local l = self:invert(self.modes)
        for _i_, x in ipairs(l) do
            local str = ""
            for _i__,y in ipairs(x) do
                if isIn(y, {1,2,3,4}) then
                    str = str.."#"
                else
                    str = str .. " "
                end
            end
            print(str)
        end
    end
    ,
    invert = function (self, list)
        local _tab_ = {}
        for x, _t_ in ipairs(list) do
            for y, v in ipairs(_t_) do
                if not _tab_[y] then _tab_[y] = {} end
                _tab_[y][x] = v
            end
        end
        return _tab_
    end
    ,
    dumpMeta = function(self)
        table.dump(self.metadata)
    end
}
Class(Map) --[[Class]]--

--[[--
map = Map:new("maps/de_cs2d.map")

--map.tiles, map.modes, map.collisions - values accessed via [x][y]
--map.gradient, map.antigradient - values accessed via ipairs()
--map.metadata - key-value table

map:dumpMeta() -- Generates dump for all MetaData members
map:mapogram() -- Generates a graphical display of the collision zone

map2 = Map:new("maps/de_dust.map") -- object map will not be effected
--]]--