Mapeate/Public/ecma/Mapeate.Mapas.ecma.js

Mapeate.Mapas = function(mapeate, entradas){

    const self = this, 
          mapas = {}, 
          cache = {};
    let iniciado = false, 
        sobreescribir_por_defecto;

    let selector = this.selector;

    const constructor = () => {

        mapeate.print("info", "mapeate_mapas_construyendose");

        selector = self.selector = new Mapeate.Mapas.Selector(mapeate, entradas);

        mapeate.print("ok", "mapeate_mapas_construido");
    
    };

    this.iniciar = callback => {

        const terminar = estado => typeof callback == "function" && callback(estado);

        mapeate.print("info", "mapeate_mapas_iniciando");

        if(iniciado){
            mapeate.print("warn", "mapeate_mapas_ya_iniciado");
            terminar(false);
            return false;
        };
        iniciado = true;

        sobreescribir_por_defecto = mapeate.configuracion(["mapas_sobreescribir", "sobreescribir"]);

        mapeate.ejecutar_array_asincrono([
            "archivos_de_mapas_por_defecto", 
            "archivos_de_mapas", 
            "mapas_por_defecto", 
            "mapas"
        ], (clave, callback) => self.cargar(mapeate.configuracion(clave), true, callback), () => {
            selector.iniciar(() => {
                mapeate.print("ok", "mapeate_mapas_iniciado");
                terminar(true);
            });
        });

        return true;
    };

    const cargar = (entradas, sobreescribir, callback, i) => {

        if(!entradas || i >= entradas.length){
            typeof callback == "function" && callback();
            return;
        };

        const terminar = () => cargar(entradas, sobreescribir, callback, i + 1);

        if(!entradas[i]){
            terminar();
            return;
        };

        if(typeof entradas[i] == "object"){
            if(entradas[i] instanceof Array)
                cargar(entradas[i], sobreescribir, terminar, 0);
            else{
                for(const clave in entradas[i])
                    if(sobreescribir || mapas[clave] === undefined)
                        mapas[clave] = entradas[i][clave];
                terminar();
            };
        }else if(typeof entradas[i] == "string"){

            const procesar = string => mapeate.procesar_json(
                string, 
                json => cargar(json instanceof Array ? json : [json], sobreescribir, terminar, 0), 
                terminar
            );

            if(/^(\{(.|[\n\r])*\}|\[(.|[\r\n])*\])$/.test(entradas[i].trim()))
                procesar(entradas[i]);
            else 
                mapeate.leer_archivo(entradas[i], procesar);

        }else 
            terminar();

    };

    this.cargar = (entradas, sobreescribir, callback) => cargar(
        typeof entradas == "object" && entradas instanceof Array ? entradas : [entradas], 
        typeof sobreescribir == "boolean" ? sobreescribir : sobreescribir_por_defecto, 
        callback, 
        0
    );

    this.coger = claves => {

        const l = (claves = mapeate.coger_array_de_strings(claves)).length;

        for(let i = 0; i < l; i ++)
            if(mapas[claves[i]] !== undefined)
                return mapas[claves[i]];
        return claves[0] || null;
    };

    this.coger_todos = () => ({...mapas});

    this.cache = (clave, datos) => datos === undefined ? cache[clave] : (cache[clave] = datos);

    this.construir = clave => {

        error = (
            clave === undefined ? 1 << 0 : 
            clave === null ? 1 << 1 : 
            typeof clave != "string" ? 1 << 2 : 
            !clave ? 1 << 3 : 
            !(clave = clave.trim()) ? 1 << 4 : 
            mapas[clave] === undefined ? 1 << 5 : 
            mapas[clave] === null ? 1 << 6 : 
        0) << 1;

        console.log(["B", error]);

        if(error)
            return;

        const mapa = {
            nombre : clave, 
            ...mapas[clave], 
            datos : cache[mapas[clave].url]
        };

        if(!mapa.datos)
            mapeate.leer_archivo(mapas[clave].url, datos => {
                cache[mapas[clave].url] = datos;
                mapa.datos = datos;
                construir(mapa);
            });
        else 
            construir(mapa);

    };

    const construir = datos => {

        const juego = mapeate.si_mismo.querySelector(".mapa"), 
              mapa = juego.querySelector(".mapa"), 
              svg = mapa.querySelector("svg"), 
              claves = ["left", "top", "width", "height"];

        juego.innerHTML = (`
            <div class="` + datos.nombre + `">` + datos.datos + `</div>
        `);

        mapeate.porcentuar(
            svg.offsetWidth, svg.offsetHeight, mapa.offsetWidth, mapa.offsetHeight
        ).forEach((valor, i) => svg.style[claves[i]] = valor + "px");

        mapeate.si_mismo.querySelector(".menu-mapas").setAttribute("data-visible", false);
        mapeate.si_mismo.querySelector(".juego").setAttribute("data-visible", true);

    };
 
    constructor();

};