Just blah

terrain.js

'use strict';

// TODO use high performance array?
var types = {
    plain: 0,
    swamp: 1,
    lava: 2,
    wall: 3
};

var terrain = [
    "plain",
    "swamp",
    "lava",
    "wall"
];

// Terrain types: plain, wall, swamp, lava
function getTerrainType(tileData) {
    var type;

    for (var i = 0; i < tileData.length; i++) {
        if (tileData[i].type === "terrain" && (
            type === undefined ||
            (type === "plain" && (tileData[i].type === "swamp" || tileData[i].type === "wall")) ||
            (type === "swamp" && tileData[i].type === "wall")
        )) {
            type = tileData[i].terrain;
        }
    }

    if (type === undefined) {
        throw new Error("Undefined type of terrain in " + JSON.stringify(tileData));
    }

    return type;
}

// This is storing map terrain data in memory
var cache = {};
function getCache(room) {
    if (room === undefined) {
        return;
    }

    if (room instanceof Room) {
        room = room.name;
    } else if (room instanceof RoomPosition) {
        room = room.roomName;
    }

    if (cache[room] === undefined) {
        // Lookup in memory first if no local cache found
        // TODO memory disabled for now - also add converter
        if (Memory.permanent.roomTerrain === undefined) {
            Memory.permanent.roomTerrain = {};
        }

        if (Memory.permanent.roomTerrain[room]) {
            // TODO convert data
            cache[room] = Memory.permanent.roomTerrain[room];
        } else {
            // Otherwise create from room data and store to local and memory cache
            var roomData = Game.rooms[room].get("room");

            if (roomData === undefined) {
                return;
            }

            cache[room] = "";
            var byte = 0;
            var twist = false;

            for (var i = 0; i < 50; i++) {
                for (var j = 0; j < 50;) {
                    byte += types[getTerrainType(roomData[j][i])] << 4;
                    j++;
                    byte += types[getTerrainType(roomData[j][i])] << 6;
                    j++;

                    if (twist) {
                        cache[room] += String.fromCharCode(byte);
                        byte = 0;
                    } else {
                        byte = byte >>> 4;
                    }
                    twist = !twist;
                }
            }
        }
    }

    return cache[room];
}
function get(room, options) {
    if (options === undefined) {
        options = {};
    }

    var result = getCache(room);

    return function(x, y) {
        var pos = x * 50 + y;
        var char = result[pos >> 2].charCodeAt(0);
        var offset = (pos & 3) << 1; // Take last 2 bits from pos, multiply by two
        console.log("Offset: " + offset.toString(2), "From: " + char.toString(2));

        char = char >>> offset; // Normalize output
        char = char & 3; // Fit mask
        console.log(char.toString(2), pos >> 2, result.length);

        return terrain[char];
    };
}

module.exports = {
    get: get,
    getCache: getCache // TODO temp
};