Parse

File Parse keyboard.js

Source

            const KC = {
    UP: ['ArrowUp', 'KeyW']
    , LEFT: ['ArrowLeft', 'KeyA']
    , RIGHT: ['ArrowRight', 'KeyD']
    , DOWN: ['ArrowDown', 'KeyS']
}


const KEYS = new Proxy(KC, {
  get(target, prop) {
    let val = target[prop]
    if(val == undefined) {
        val = target[prop] = this.detectStore(target, prop)
    }
    return val
  }

  , detectStore(target, prop) {
        if(prop.length == 1) {
            return [`Key${prop.toUpperCase()}`]
        }

        // console.warn('Unknown KEY', prop)
        return [prop.toUpperCase()]
  }
});



class StageKeyboard {
    autoListen = true

    constructor(stage=undefined) {
        this.stage = stage

        this.data = { keydown: [], keyup: [] }
        this.wake()
    }

    wake(){
        let p = this.getEventParent()
        p.addEventListener('keydown', this.stageKeydownHandler.bind(this))
        p.addEventListener('keyup', this.stageKeyupHandler.bind(this))

    }

    stageKeydownHandler(ev) {

        let p = this.stage
        if(p.onKeydown) {
            p.onKeydown(ev)
        }
        return this.genericHandler(ev)
    }

    genericHandler(ev) {
        for(let item of this.data[ev.type]) {
            if(this.matchCode(ev, item)) {
                // console.log('YEY!')
                item.handler(ev)
            }
        }
    }

    matchCode(ev, item) {
        let code = ev.code.toLowerCase()
        // console.log('Code', code)
        if(item.codes == undefined) {
            console.warn('Bad Key Load', item)
            return
        }

        for (var i = item.codes.length - 1; i >= 0; i--) {

            if(item.codes[i].toLowerCase() == code) {
                return true
            }
        }

        return false
    }

    stageKeyupHandler(ev) {

        let p = this.stage
        if(p.onKeyup) {
            p.onKeyup(ev)
        }
        return this.genericHandler(ev)
    }

    getEventParent() {
        return window //this.stage.canvas
    }

    receiverFunction(prop) {
        /* Unknoen prop call. */
        return (codes, func, props) => {
            // console.log('prop', prop, handler)
            return this.on(prop, func, props)
        }
    }

    onKeydown(codes, handler) {
        this.data['keydown'].push({codes, handler})
    }

    onKeyup(codes, handler) {
        this.data['keyup'].push({codes, handler})
    }


}



const keyboardHandler = function(parent) {

    const unknownAttrProxyHandler = {
        get(target, prop, receiver) {

            if(target[prop] !== undefined) {
                // return target[prop].apply(target, arguments)
                return Reflect.get.apply(target,arguments);
            }
            console.log('Return receiver')

            return target.receiverFunction(prop)
        }
    };

    const target = new StageKeyboard(parent)
    const eventNameHandlerProxy = new Proxy(target, unknownAttrProxyHandler);
    return eventNameHandlerProxy;
}



Polypoint.head.install(StageKeyboard)

Polypoint.head.lazierProp('Stage', function keyboard(){
    return keyboardHandler(this)
})

copy