livecodingspace-app/support/proxy/vwf.example.com/aframe/turtlelsys.vwf.yaml

# Turtle for L-System
--- 
extends: http://vwf.example.com/aframe/asphere.vwf
type: "turtle"
properties:
    position: [1, 1.25, -4]
    color: "#e0e014"
    radius: 0.3
    wireframe: true
    angleInRadians: 0
    counter: 1
    iteration:
        set: |
            this.iteration = value;
            this.makeLSys();
        value: 3
    angle:
        set: |
            this.angle = value;
            this.makeLSys();
        value: 60  
    stepLength: 
        set: |
            this.stepLength = value;
            this.makeLSys();
        value: 0.5  
    rule: 
        set: |
            this.rule = value;
            this.makeLSys();
        value: 'F++F++F'
    axiomF: 
        set: |
            this.axiomF = value;
            this.makeLSys();
        value: 'F-F++F-F'
    axiomG:
        set: |
            this.axiomG = value;
            this.makeLSys();
        value: ''
    lsys: ''
    ready: false
children:
    drawNode:
        extends: http://vwf.example.com/aframe/aentity.vwf
    lsysLang:
        extends: http://vwf.example.com/ohm/node.vwf
        properties:
            grammar:
            semantics:
            ohmLang: |
                LSys { Gen<x> 
                        = ReadRule+ 
                        ReadRule 
                        = letters | symbols
                        letters  = "F" | "G" 
                        symbols  = "-" | "+" }
        methods:
            initLang:
                body: |
                    console.log("add operations to semantics")
                    this.addOperationLang();
            addOperationLang:
                body: |
                    this.semantics.addOperation('gen(x)', {
                        Gen: function(e)
                        {
                            return e.gen(this.args.x);
                        },
                        ReadRule: function(e)
                        {
                            return e.gen(this.args.x);
                        },
                        letters: function(_)
                        {
                            for (var propName in this.args.x)
                            {
                                if (propName == this.sourceString)
                                    return this.args.x[propName]
                            }
                            return this.sourceString
                        },
                        symbols: function(_)
                        {
                            return this.sourceString;
                        }
                    });
    turtleLang:
        extends: http://vwf.example.com/ohm/node.vwf
        properties:
            grammar:
            semantics:
            ohmLang: |
                Turtle {
                Draw<x, y> 
                    = (drawLetter | turn)+ 
                drawLetter 
                    = letter
                turn 
                    = "+" | "-" }
        methods:
            initLang:
                body: |
                    console.log("add operations to semantics")
                    this.addOperationLang();
            addOperationLang:
                body: |
                    var turtleID = this.parent.id;
                    var self = this;
                    this.semantics.addOperation('draw(x,y)', {
                        Draw: function(e)
                        {
                            e.draw(this.args.x, this.args.y);
                        },
                        drawLetter: function(e)
                        {
                            //vwf_view.kernel.callMethod(turtleID, 'goForward', [this.args.x]);
                            self.parent.goForward(this.args.x);
                        },
                        turn: function(e)
                        {
                            if (this.sourceString == "+")
                                //vwf_view.kernel.callMethod(turtleID, 'turn', [this.args.y]);
                                self.parent.turn(this.args.y);
                            if (this.sourceString == "-")
                                // vwf_view.kernel.callMethod(turtleID, 'turn', [-1 * this.args.y]);
                                self.parent.turn(-1*this.args.y);
                            }
                    });  
methods:
    clearDraw: |
        let self = this
        let drawDef = {
            "extends": "http://vwf.example.com/aframe/aentity.vwf",
        }
        this.children.delete(this.drawNode);
        this.children.create("drawNode", drawDef);
        this.angleInRadians = 0
        //this.drawNode.children.forEach(el => {
        //   self.drawNode.children.delete(el)
        //})
    parseLSys: |
        var str = this.rule;
        var axioms = {"F": this.axiomF, "G": this.axiomG};
        for (var i = 1; i < this.iteration; i++)
        {
            var match = this.lsysLang.grammar.match(str, 'Gen<"y">');
            if (match.succeeded()){
            var res = this.lsysLang.semantics(match).gen(axioms);
            str = res.join("");
            }
        }
        console.log(str);
        this.lsys = str;
    makeLSys: |
        if (this.ready) 
        {
        this.clearDraw();
        this.parseLSys();
        this.future(0.1).drawLSys();
        }
    drawLSys: |
        var match = this.turtleLang.grammar.match(this.lsys, 'Draw<"1","1">');
        if (match.succeeded()){
            var res = this.turtleLang.semantics(match).draw(this.stepLength, this.angle);
        }
    makeMe:
        parameters:
                - childName
                - startPosition
                - endPosition
        body: |
                //let nodeId = this.drawNode.id;
                var childComponent = {
                                    "extends": "http://vwf.example.com/aframe/lineComponent.vwf",
                                    "type": "component",
                                    "properties": {
                                        "start": startPosition,
                                        "end": endPosition,
                                        "color": "green"
                                    }
                                }
                    //vwf_view.kernel.createChild(this.id, childName, childComponent);
                    this.drawNode.children.create(childName, childComponent);
    turn:
        parameters:
            - angle
        body: |
            var angle0 = this.angleInRadians;
            var targetAngle = angle * Math.PI / 180.0;
            this.angleInRadians = angle0 + targetAngle;
    goForward:
        parameters:
            - step
        body: |
            let pos = AFRAME.utils.coordinates.parse(this.drawNode.position);
            var x0 = pos.x;
            var y0 = pos.y;
            var xx = Math.sin(this.angleInRadians);
            var yy = Math.cos(this.angleInRadians);
            let endPosition = AFRAME.utils.coordinates.stringify({x: x0 + step * xx, y: y0 + step * yy, z: pos.z});
            this.counter = this.counter + 1;
            this.makeMe('line__' + this.counter, this.drawNode.position, endPosition);
            this.drawNode.position = endPosition;
    initialize:
        body: |
            this.ready = true;
            console.log("initialising turtle");
            //vwf_view.kernel.callMethod(this.id, "testDrawLsys");