LLSE DoAsVue-基于LXL的js插件开发框架【全网首发：支持注解编程】【因为LXL已经支持nodejs，该项目停止维护】 1.15.52

执行流程：
    0、初始化子插件，进行必要的数据搜集与整理
    1、初始化全局域，添加全局变量
    2、初始化继承
    3、创建data数据域
    4、建立require引用
    5、建立methods方法域
    6、注入注解，执行注解逻辑
    7、创建aspect切面,并插入切面
    8、建立listen监听事件
    9、注册命令
    10、执行入口main

var plugin = {
    data(){
        return{ //数据域、属性域
 
        }
    },
    global:{
        testkey:"testvalue", //所有DoAsVue插件可访问该变量，直接使用，例如log(testkey)
    },
    extends:null, //继承，可以继承其他DoAsVue插件，只能继承一个   extends:"插件名称"
    require:{ //引用域，可以用其他DoAsVue插件
 
    },
    methods:{ //方法域，可以定义方法（函数），这里的方法可以被切面修改，带有 _ 前缀的算作私有方法
              //这里的方法可以写到methods外边，但是不会被继承，即，写到外边的也算是私有方法
              //如果外边的方法与methods内的方法名重复，会被methods内的覆盖
 
    },
    MCListen:{ //监听域，就和mc.listen一样
 
    },
    MCPlayerCmd:{ //注册玩家命令

    },
    MCConsoleCmd:{ //注册控制台命令

    },
    aspect:{ //切面域，可以对引用的插件methods进行切面修改（会影响到被切面的插件的methods正常执行）
 
    },
    main(){ //主动执行入口，一般用来初始化
          //当main返回一个函数时，例如return ()=>{ /*todo*/ } 它表示是在所有插件执行完毕main之后执行该返回函数；
         //有时候会有这种需求，比如在main调用其他插件时，但是其他插件可能这个时候并未初始化完毕，直接调用会出现数据不存在引发的undefined错误，因此需要等待他们都初始化完毕之后再执行。
    }
 
}

module.exports={
    name:"template_plugin1", //表示这个插件的名字，用于被其他插件引用时的名字
    plugin:plugin//当前导出的创建对象
}

//LiteXLoader Dev Helper
/// <reference path="c:\Users\KING\.vscode\extensions\moxicat.lxldevhelper-0.1.4/Library/JS/Api.js" />
//新增对 class 的支持，目的就是为了更好的使用继承。因此你可以在这里使用 require导入其他的class，然后继承
//就像平常一样使用class
//例如 let yourclass = require (你的class路径），然后继承你的class即可

var plugin = class Plugin{
    data(){
        return{
 
        }
    };
    global={
        testkey:"testvalue",
    };
    extends=null;
    require={
 
    };
    methods={
 
    };
    MCListen={
 
    };
    MCPlayerCmd={

    };
    MCConsoleCmd={

    };
    aspect={
 
    };
    main(){
        this.print("DoAsVue启动  \\ \\ \\\\q( 'ω' )p// / /")
    }
}

//导出规范
module.exports={
    name : "classtemp", //表示这个插件的名字，用于被其他插件引用时的名字
    plugin : plugin //导出当前的class
}

//LiteXLoader Dev Helper
/// <reference path="c:\Users\KING\.vscode\extensions\moxicat.lxldevhelper-0.1.4/Library/JS/Api.js" />

/**
 执行流程：
    1、初始化全局域
    2、执行继承初始化
    3、创建data数据域
    4、建立require引用
    5、建立methods方法域
    6、创建aspect切面,并插入切面
    7、建立listen监听事件
    8、注册命令
    9、执行入口main
 */
var plugin = {
    data(){
        return{
            name:"template plugin 1",//任意的数据
        }
        //定义数据域
        //用法，直接在以下的每个区域this.XXX即可使用，例如 this.name
    },
    require:{
        //引用域
        //引用别的模块
        // plugin1:plugin1,
        // plugin2:plugin2,
        // plugin3:plugin3,
        // ....
        //用法，直接在以下的每个区域this.plugin1即可使用另一个插件
    },
    methods:{
        //自定义方法域
        //fun:(paramater){}
        //用法，直接在以下的每个区域this.fun(xxx)即可使用，例如this.add(123,456)
 
        show:function(){
            log("这里是 "+this.name+" 的函数show()")
        },
        add(num1,num2){
            return num1+num2;
        }
    },
    MCListen:{
        //监听域
        //监听事件区，即mc.listen()
        //用法：例如：onMove:(player){}
    },
    MCPlayerCmd:{ //注册玩家命令，详情请查看template_plugin2.DAVue.js
 
    },
    MCConsoleCmd:{ //注册控制台命令，详情请查看template_plugin2.DAVue.js
 
    },
    aspect:{
        //切面域
        //如何“切开”其他的plugin请查看template_plugin2.js
        //支持：执行前，执行时，执行完毕返回前
        // 插件名称:{ //详情查看template_plugin2.DAVue.js
        //     before:{
        //         //todo
        //     },
        //     beforeRun:{
        //         //todo
        //     },
        //     beforeReturn:{
        //         //todo
        //     }
        // }
    },
    main(){
        //主动执行的入口，即在当前插件一切准备就绪之后主动执行
        //只能执行methods内的方法
        log("\n--------"+this.name+" main--------")
        this.show()
        var result = this.add(1000,2000);
        log("1000+2000结果是："+result);//这里结果是6000，因为被template_plugin2切面修改了
        log("--------"+this.name+" main--------\n")
    }
 
}
//导出规范
module.exports={
    name:"template_plugin1", //表示这个插件的名字，用于被其他插件引用时的名字
    plugin:plugin//当前导出的创建对象
}
//++++++++++++++++++++++++++++++++//
//插件模块之间协调与调用请查看template_plugin2.js
//++++++++++++++++++++++++++++++++//

//LiteXLoader Dev Helper
/// <reference path="c:\Users\KING\.vscode\extensions\moxicat.lxldevhelper-0.1.4/Library/JS/Api.js" />
var plugin = {
    data(){
        return{
            name:"template plugin 2",//自定义数据data
        }
    },
    require:{
        plugins1:"template_plugin1" //引用template_plugin1插件
    },
    methods:{
        fun:function(){
            log("这里是："+this.name)
            log("在template_plugin 2里执行template_plugin 1的函数")
            this.plugins1.show();//使用别的plugins方法
            log("获取到 "+this.require.plugins1+" 的data数据:"+this.plugins1.name);//使用别的plugins数据
        }
    },
    MCListen:{
        onJump:function(player){
            log("当前执行监听跳跃事件的插件是："+this.name)
            log(player.realName+" 跳了一下")
        }
    },
    MCPlayerCmd:{ //注册玩家命令
        hello:{ //名称
            cmd:"hello",//注册的命令
            permission:0, //权限等级
            description:"说hello", //命令说明
            event:function(player,args){ //执行的函数
                player.tell("玩家你好你好")
            }
        }
    },
    MCConsoleCmd:{ //注册控制台命令
        consoleHello:{
            cmd:"console hello",
            description:"你好",
            event:function(args){
                log("控制台你好")
            }
        }
    },
    aspect:{
        /**
            所谓切面，即在不直接修改其他插件的method源码前提下修改这个method
         */

        //注：只能对其他插件的methods进行切入与修改
        //支持多重切入
        //但是至于同一个插件被多个插件进行切面的优先等级，理论上是取决于被DoAsVue.lxl.js加载的顺序（File.getFilesList）
        plugins1:{
            before:{
                //这个表示在plugins1插件模块执行add（）方法之前先执行当前方法
                add:function(){
                    log(this.require.plugins1+" 执行add前插入了一个函数")
                }
            },
            beforeRun:{
                //这个表示在plugins插件模块执行add（）时，拦截他的传入参数，并允许修改
                add:function(...args){ //这里也可以换成  add:function(num1,num2)，返回时需要返回数组[num1,num2]
                    //args:传入show的数据
                    log(this.require.plugins1+" 执行add时,接收到的参数："+args)
                    args[1]=5000;
                    log("现在修改为: "+args)
                    return args;
                    //切记要返回参数，否则被切面的函数会得不到参数
                }
            },
            beforeReturn:{
                //这个表示在plugins插件模块执行add（）完毕之后，即将要返回结果之前，拦截他的返回结果，通过修改result，可以修改返回结果
                add:function(result){
                    //result:执行完毕之后的结果
                    log(this.require.plugins1+" 执行add返回前，结果应该是"+result+",但是现在修改为6666")
                    result=6666;
 
                    //add返回的数据
                    return result;
                }
            }
        }
    },
    main(){
        log("\n--------"+this.name+" main--------")
        this.fun()
        log("--------"+this.name+" main--------\n")
    },
}
//导出规范
module.exports={
    name:"template_plugin2",
    plugin:plugin
}

var plugin = {
    data(){
        return{
           obj:{
              a:1,
              b:2
           }
        }
    },
    extends:null,
    methods:{
        m(){
            log("这里是父类")
        }
    },
    main(){
        this.m();
    }
}

//导出规范
module.exports={
    name:"B", //表示这个插件的名字，用于被其他插件引用时的名字
    plugin:plugin//当前导出的创建对象
}

//-------------------------------------------------------------------------------


var plugin = {
    data(){
        return{
 
        }
    },
    extends:"B",
    methods:{
 
    },
    main(){
        log("继承B的obj：")
        log(this.obj)
        log("执行继承于父插件的m方法：")
        this.m();
    }
}

//导出规范
module.exports={
    name:"A", //表示这个插件的名字，用于被其他插件引用时的名字
    plugin:plugin//当前导出的创建对象
}

global:{
    key1：value1,
    key2：value2,
    ....
}

var plugin = {
    data(){
        return{
           private__value1:"abc", //仅自身可以访问
           protection__value1:"abc", //仅自身和子插件可以访问
        }
    },
    extends:null,
    methods:{
        private__Fun(){
 
        },
        protection__Fun(){
 
        },
    },
    main(){
 
    }
}

//导出规范
module.exports={
    name:"Temp", //表示这个插件的名字，用于被其他插件引用时的名字
    plugin:plugin//当前导出的创建对象
}

var plugin = {
    data(){
        return{}
    },
    global:{},
    extends:"BaseAnnotationOperator",
    require:{},
    methods:{
        //参数必须为整数的注解
        //用法 @argMustBeInteger(argsIndex)
        //argsIndex：参数下标，如果不填，默认所有参数都必须是整数
        argMustBeInteger(method,methodName,annotationInfo,module,argIndex){
            /**
             * @annotation
             */
 
            //使用元注解将 argMustBeInteger 标记为一个注解
            /**
             * 参数前面 method,methodName,annotationInfo,module 这几个是固定的
             * method：是被注解标注的 函数 本身
             * methodName：函数 的真实名称
             * annotationInfo：函数的所有注解信息
             * module：这个函数所在的子插件本身
             *
             *
             * argIndex：这个是注解传入的参数
             * 例如 @argMustBeInteger (1) 表示下标为 1 的参数必须是整数
             * 注：注解可以传入多个参数，我这里只是传入一个举例而已，
             * 它的原型是 (method,methodName,annotationInfo,module,...args)
             */


            //返回一个代理方法
            return function(...args){
                //当不填写参数下标时，默认检查所有参数
                if(argIndex == null){
                    //遍历所有参数
                    for(let index in args){
                        if(args[index] == null ||
                            typeof(args[index]) != "number" ||
                            Math.round(args[index])!= args[index]){
      
                                throw Error(annotationInfo["argsName"][index]+" must be an integer")
                        }
                    }
                }else if(args!=null && args.length > argIndex){
                    //如果填写了参数下标，就只检查特定参数
                    if(args[argIndex] == null ||
                        typeof(args[argIndex]) != "number" ||
                        Math.round(args[argIndex])!= args[argIndex]){
  
                            throw Error(annotationInfo["argsName"][argIndex]+" must be an integer")
                    }
                }
                //执行
                return method(...args);
            }
        }
    },
    MCListen:{},
    MCPlayerCmd:{},
    MCConsoleCmd:{},
    aspect:{},
    main(){}
}

//导出规范
module.exports={
    name:"AnnotationLib", //表示这个插件的名字，用于被其他插件引用时的名字
    plugin:plugin//当前导出的创建对象
}

add(num1,num2,num3){
    /**
     * @argMustBeInteger (1)
     */

     return num1+ num2 + num3;
},

this.print(this.add(1.2, 2.2 ,5.8)) //会报错，因为注解要求了第二个（下标为1）的参数必须是整数

this.print(this.add(1.2, 2 ,5.8)) //不报错，会正常打印 9

        fun(){
            /**
             * @annotation1
             * @annotation2()
             * @annotation3 ()
             * @annotation4("value1",123,new Date())
             * @annotation5 ("value1",123,new Date())
             * @annotation6 ("value1",null)
             */

            //todo 你的代码在必须注解之后
        }
//1、注解必须在函数内部的头部
//2、与上面的格式相仿
//3、不支持在注解后面添加解释，例如    * @annotation1 //这是注解1

// MyBeanFactory.DAVue.js
var plugin = {
    data(){
        return{}
    },
    extends:null,
    methods:{
        setNumBean(){
            /**
             * @Bean ("myNum")
             */
            return 123;
        },
        setObjBean(){
            /**
             * @Bean ("myObj")
             */
            return {
                a:999,
                b:"自动注入"
            };
        },
    },
    main(){}
}

//导出规范
module.exports={
    name:"MyBeanFactory", //表示这个插件的名字，用于被其他插件引用时的名字
    plugin:plugin//当前导出的创建对象
}

// temp.DAVue.js
var plugin = {
    data(){
        return{
            num : null,
            obj : null
        }
    },
    extends:null,
    methods:{
        setValue(num,obj){
            /**
             * @Autowired (["myNum","myObj"],true)
             */

            this.num = num;
            this.obj = obj;
        }
    },
    main(){
        this.print(this.value);
        this.printObject(this.obj)
    }
}

//导出规范
module.exports={
    name:"temp", //表示这个插件的名字，用于被其他插件引用时的名字
    plugin:plugin//当前导出的创建对象
}

var plugin = {
    data(){
        return{}
    },
    extends:null,
    methods:{
        fun(arg1,arg2){
 
        },
    },
    main(){}
}

//导出规范
module.exports={
    name:"Temp", //表示这个插件的名字，用于被其他插件引用时的名字
    plugin:plugin//当前导出的创建对象
}

      在其他插件需要调用该子插件的fun(args)，只需要执行:
      mc.runcmdEx("davue execute Temp fun arg1 arg2")

        //快速修改玩家血量举例：
        let playerNbt_jsObjNbt = this.NBTHelper.getJsObjNbt(players[0].getNbt())
        let Attributes = playerNbt_jsObjNbt.Attributes;
        for(let i in Attributes){
            let attribute = Attributes[i];
            if(attribute.Name=="minecraft:health"){
                playerNbt_jsObjNbt.Attributes[i].Current = 19; //修改血量
                players[0].setNbt(playerNbt_jsObjNbt.getNbt()); //写入数据
                break;
            }
        }

        //--------------------------------------------//
            // 快速制作 锋利32k 钻石剑
            let ItemSNBT  = `{"Count":1b,"Damage":0s,"Name":"minecraft:diamond_sword","WasPickedUp":0b,"tag":{"Damage":0,"RepairCost":3,"display":{"Name":"钻石剑-自定义名字"},"ench":[{"id":17s,"lvl":3s},{"id":9s,"lvl":5s}]}}`;
            let item_jsObjNbt = this.NBTHelper.getJsObjNbt(ItemSNBT)
            let item = mc.newItem(item_jsObjNbt.Name,item_jsObjNbt.Count);
            item_jsObjNbt.tag.ench[1].lvl=32767; //直接修改为32k
            item.setNbt(item_jsObjNbt.getNbt());

        //如此便捷的nbt操作，心动了吗？