class GuaAnimation {
    constructor(game) {
        this.game = game
        this.frames = []
        for (let i = 0; i < 3; i++) {
            // let name = 'player'+i
            let name = `player${i}`
            let t = this.game.getImgFromName(name)
            //当一个变量用一会儿就不用的时候,就用一个字母代替
            this.frames.push(t)
        }
        this.texture = this.frames[0]
        this.frameIndex = 0;
        this.frameCount = 3;
        this.x = 50
        this.y = 50
    }

    static new(game) {
        return new this(game)
    }

    update() {
        this.frameCount--
        if (this.frameCount <= 0) {
            this.frameCount = 3
            this.frameIndex = (this.frameIndex + 1) % this.frames.length
            this.texture = this.frames[this.frameIndex]
        }
        //这样使得每三帧切换一次图片
    }

    draw() {
        log(this.frameIndex)
        this.game.drawImage(this)
    }
}

frames(){
	return this.animations[this.animationName]
}

//使用反引号 (``) 来代替普通字符串中的用双引号和单引号。模板字符串可以包含特定语法（${expression}）的占位符

var createStrWithFormat = function (string) {
    try {
        var args = arguments;
        var pattern = new RegExp("%([0-9]+)", "g");
        return String(string).replace(pattern
            , function (match, index) {
                if (index == 0 || index >= args.length) {
                    throw "Invalid index in format string";
                }
                return args[index];
            });
    } catch (e) {
        log("createWithFormat error : " + e);
        return "";
    }
}
createStrWithFormat("this is a %1 speaking", "male")

const drawNes = bytes => {
        let canvas = e("#id-canvas")
        let context = canvas.getContext('2d')
        let tileNum = 8//一页8x8个tiles
        let tileSize = 8//一个tile有8x8个像素
        let pixelwidth = 10//每个像素的宽度
        let numberOfBytesPerTile = 16//16个字节一个图块
        for (let i = 0; i < tileNum; i++) {
            for (let j = 0; j < tileNum; j++) {
                //算出bytes
                let x = j * tileSize * pixelwidth
                let y = i * tileSize * pixelwidth
                let index = window.offset + (i * tileNum + j) * numberOfBytesPerTile
                //其实应该drawTile更准确
                drawTile(context, bytes.slice(index), x, y, pixelwidth)
            }
        }
    }

const drawTile = (context, data, x, y, pixelwidth) =>{
    const colors = [
        'white',
        '#fe1000',
        '#ffb010',
        '#aa3030',
    ]
    let w = pixelwidth
    let h = pixelwidth
    for (let i = 0; i < 8; i++) {
        let p1 = data[i]
        let p2 = data[i + 8]
        for (let j = 0; j < 8; j++) {
            //8 bit per line
            //在j循环中每一次画一个像素点
            //78 69
            //0100 1110   0100 0101
            let c1 = (p1 >> (7 - j)) & 0b00000001
            let c2 = (p2 >> (7 - j)) & 0b00000001
            let pixel = (c2 << 1) + c1
            // if (pixel == 0){
            //     continue
            // }
            let color = colors[pixel]
            context.fillStyle = color
            let px = x + j * w
            let py = y + i * h
            context.fillRect(px, py, w, h)
        }
    }
}

const actions = {
    change_offset(offset) {
        window.offset += offset
        e('h3').innerHTML = window.offset
        drawNes(window.bytes)
    },
}
const bindEvent = () => {
    e('.gua-controls').addEventListener('click', event => {
        let action = event.target.dataset.action
        let offset = Number(event.target.dataset.offset)
        actions[action] && actions[action](offset)
    })
}

var SupportPoolHero = cc.Sprite.extend({
    _hp : 0,    // 血量
    _sp : 0,    // 愤怒
    _mp : 0,    // 魔法
    ctor: function (hp, mp, sp) {
        this._super(res.sh_node_64_png);
        this.initData(hp, mp, sp);
    },
    initData: function (hp, mp, sp) {
        this._hp, this._mp, this._sp = hp, mp, sp;
    },
    unuse: function () {
        this._hp = this._mp = this._sp = 0;
        this.retain(); // 使其引用计数+1，防止被内存回收
        this.removeFromParent();
    },
    reuse: function (hp, mp, sp) {
        this.initData(hp, mp, sp);
    }
});

SupportPoolHero.create = function (hp, mp, sp) {
    return new SupportPoolHero(hp, mp, sp)
};

SupportPoolHero.reCreate = function (hp, mp, sp) {
    // 判断[对象缓冲池中是否有可用对象]
    if (cc.pool.hasObject(SupportPoolHero)){
        // 从对象缓冲池中获取对象
        return cc.pool.getFromPool(SupportPoolHero, hp, mp, sp);
    }else{
        // 创建一个新的对象
        return  SupportPoolHero.create(hp, mp, sp);
    }
};




var CCPoolLayer = cc.Layer.extend({
    createCount         : 3000,
    createHeroList      : [],
    reCreateHeroList    : [],
    timeList            : {},
    ctor : function(){
        this._super();
        // 加载[菜单]_2种方式创建对象
        this.loadMenu();
        // 加载[标签]_加载时间反馈
        this.loadLabelInfo();
        // 为pool准备对象
        this.prepareHeroForPool();
    },
    // 加载[菜单]_2种方式创建对象
    loadMenu : function(){
        // 创建[标签]_按钮文本说明
        var labCreate = new cc.LabelTTF("直接创建" + this.createCount + "个精灵！", "Arial", 24);
        var labReCreate = new cc.LabelTTF("使用pool创建" + this.createCount + "个精灵！", "Arial", 24);

        // 创建[菜单项]
        var itemCreate = new cc.MenuItemLabel(labCreate, this.addSpriteByCreate, this);
        var itemReCreate = new cc.MenuItemLabel(labReCreate, this.addHeorByPool, this);

        // 创建[菜单]
        var menu = new cc.Menu(itemCreate, itemReCreate);
        menu.alignItemsHorizontallyWithPadding(150);
        this.addChild(menu);
    },
    // 加载[标签]_加载时间反馈
    loadLabelInfo : function(){
        // 创建[标签]
        this.labDirect = new cc.LabelTTF("直接创建耗费:", "Arial", 18);
        this.labDirect.setPosition(cc.pAdd(cc.visibleRect.center, cc.p(-230, -65)));
        this.labDirect.anchorY = 0;
        this.addChild(this.labDirect);

        // 创建[标签]
        this.poolLabel = new cc.LabelTTF("使用pool创建耗费:", "Arial", 18);
        this.poolLabel.setPosition(cc.pAdd(cc.visibleRect.center, cc.p(200, -65)));
        this.poolLabel.anchorY = 0;
        this.addChild(this.poolLabel);
    },
    // 准备工作[创建好对象，并把他们放入对象缓冲池]
    prepareHeroForPool : function(){
        for (var i = 0; i < this.createCount; i++) {
            var node = SupportPoolHero.create(0, 0, 0);
            this.addChild(node);
            cc.pool.putInPool(node);
        }
    },
    // 添加[精灵]_直接生成
    addSpriteByCreate: function () {
        this.createHeroList = [];
        this.timeStart("directly");
        for (var i = 0; i < this.createCount; i++) {
            var node = SupportPoolHero.create(1, 2, 3);
            this.createHeroList.push(node);
            this.addChild(node);
            node.setPosition(10 * i, cc.visibleRect.height * 0.8);
        }
        this.setDirectLabel(this.timeEnd("directly"));
        this.scheduleOnce(function(){
            for (var i = 0; i < this.createHeroList.length; i++) {
                this.createHeroList[i].removeFromParent(true);
            }
            this.createHeroList = [];
        }, 0.5);
    },
    // 从pool中获取英雄
    addHeorByPool: function () {
        this.reCreateHeroList = [];
        this.timeStart("use Pool");
        for (var i = 0; i < this.createCount; i++) {
            var node = SupportPoolHero.reCreate(4, 5, 6);
            this.reCreateHeroList.push(node);
            this.addChild(node);
            node.setPosition(10 * i, cc.visibleRect.height * 0.8);
        }
        this.setPoolLabel(this.timeEnd("use Pool"));
        this.scheduleOnce(function(){
            for (var i = 0; i < this.reCreateHeroList.length; i++) {
                cc.pool.putInPool(this.reCreateHeroList[i]);
            }
            this.reCreateHeroList = [];
        }, 0.5);
    },
    timeStart: function (name) {
        this.timeList[name] = {startTime: Date.now(), EndTime: 0, DeltaTime: 0};
    },
    timeEnd: function (name) {
        var obj = this.timeList[name];
        obj.EndTime = Date.now();
        obj.DeltaTime = obj.EndTime - obj.startTime;
        return obj.DeltaTime;
    },
    setDirectLabel: function (time) {
        if (time == 0) {
            time = "<1";
        }
        this.labDirect.setString("直接创建耗费:" + time + "ms");
    },
    setPoolLabel: function (time) {
        if (time == 0) {
            time = "<1";
        }
        this.poolLabel.setString("使用pool创建耗费::" + time + "ms");
    }
});

var BatchNodeLayer = cc.Layer.extend({
    batchNode : null,
    ctor : function(){
        this._super();
        // 第一步：加载[资源]
        this.loadResource();
        // 第二步：加载[BatchNode]
        this.loadBatchNode();
        // 第三步：加载[8000个精灵]
        this.loadSomePrince();
    },
    // 加载[资源]
    loadResource : function(){
        cc.textureCache.addImage(res.u13_prince_png);
        cc.spriteFrameCache.addSpriteFrames(res.u13_prince_plist);
    },
    // 加载[SpriteBatchNode]
    loadBatchNode : function(){
        this.batchNode = new cc.SpriteBatchNode(res.u13_prince_png);
        this.addChild(this.batchNode);
    },
    // 加载[8000个精灵]_并将其添加到this.batchNode中
    loadSomePrince : function(){
        var node = null;
        var pos = cc.p(0, 0);
        for (var i = 0; i < 8000; i++) {    // 创建8000个精灵
            node = new cc.Sprite("#prince_stand_1.png");
            //this.batchNode.addChild(node);  // 添加到batchNode对象中
            this.addChild(node);

            pos.x = Math.random() * cc.visibleRect.width;
            pos.y = Math.random() * cc.visibleRect.height;
            node.setPosition(pos);
        }
    }
});

var BakeLayer = cc.Layer.extend({
    lastPrince : null,
    ctor : function(){
        this._super();

        this.loadMenu();
        this.loadSomePrince();
    },
    loadMenu : function(){
        var itemBake = new cc.MenuItemFont("bake", this.onBake, this);
        var itemUnbake = new cc.MenuItemFont("unbake", this.onUnbake, this);
        var itemRunAction = new cc.MenuItemFont("run action", this.onRunAction, this);

        var menu = new cc.Menu(itemBake, itemUnbake, itemRunAction);
        this.addChild(menu, 1);
        menu.alignItemsVertically();
        menu.x = cc.winSize.width - 100;
        menu.y = cc.winSize.height - 80;
    },
    loadSomePrince : function(){
        var node = null;
        var pos = cc.p(0, 0);
        for (var i = 0; i < 8000; i++) {    // 创建8000个精灵
            node = new cc.Sprite("#prince_stand_1.png");
            this.addChild(node);

            // 属性配置
            pos.x = Math.random() * cc.winSize.width + 150;
            pos.y = Math.random() * cc.winSize.height * 0.65;
            node.setPosition(pos);

            this.lastPrince = node;
        }
    },
    onBake : function(){
        this.bake();
    },
    onUnbake : function(){
        this.unbake();
    },
    onRunAction : function(){
        var move = cc.moveBy(2, cc.p(0, -200));
        //this.runAction(move);

        this.lastPrince.runAction(move);
    }
});