Scenario tutorial day two: Part 3: Hands-on GEMOC, the logo turtle language

import fr.inria.diverse.k3.al.annotationprocessor.Main

@Main
def void run(){
    // println('hello world')
    val MessagingSystemManager msManager = new MessagingSystemManager
    val ms = msManager.createBestPlatformMessagingSystem("Logo","Simple Logo interpreter")

    ms.debug("Hello world on "+_self.eResource.URI, "Logo")
}

@Aspect(className=LogoProgram)
class LogoProgramAspect {

    @Step
    @InitializeModel
    def void initializeModel(EList<String> args){
        val context = VmFactory.eINSTANCE.createInterpreterRuntimeContext
        context.turtle = VmFactory.eINSTANCE.createTurtle
        val point = VmFactory.eINSTANCE.createPoint
        point.x = 0
        point.y = 0
        context.turtle.reachedPoints.add(point)
        context.turtle.position = point
        _self.runtimeContext = context
    }

@Aspect(className=LogoProgram)
class LogoProgramAspect {
    @Step
    @Main
    def void run(){
        val context = _self.runtimeContext as InterpreterRuntimeContext
        context.logger.debug("Running "+_self.eResource.URI, "Logo")

        _self.instructions.forEach[i | i.run(_self.runtimeContext as InterpreterRuntimeContext)]
    }
}

@Aspect(className=Instruction)
class InstructionAspect {
    @Step
    def void run(InterpreterRuntimeContext context){
        context.logger.error("run of " +_self +" should never occur, please write method run for this class",
            "Logo")
    }
}

@Aspect(className=Expression)
class ExpressionAspect {
    def Integer eval(InterpreterRuntimeContext context){
        context.logger.error("eval of " +_self +" should never occur, please write method run for this class",
            "Logo")
        return 0;
    }
}

@Aspect(className=If)
class IfAspect extends ControlStructureInstructionAspect {
    @Step
    def void run(InterpreterRuntimeContext context){
        context.logger.debug("run of " +_self, "Logo")
        if(_self.condition.eval(context) == 1) {
            _self.thenPart.run(context)
        } else {
            _self.elsePart.run(context)
        }
    }
}

@Aspect(className=Constant)
class ConstantAspect extends ExpressionAspect {
    def Integer eval(InterpreterRuntimeContext context){
        context.logger.debug("eval of " +_self, "Logo")
        return _self.integerValue
    }
}

@Aspect(className=Plus)
class PlusAspect extends ExpressionAspect {
    def Integer eval(InterpreterRuntimeContext context){
        return _self.lhs.eval(context) + _self.rhs.eval(context)
    }
}

@Aspect(className=Minus)
class MinusAspect extends ExpressionAspect {
    def Integer eval(InterpreterRuntimeContext context){
        return _self.lhs.eval(context) - _self.rhs.eval(context)
    }
}

@Aspect(className=Equals)
class EqualsAspect extends ExpressionAspect {

    def Integer eval(InterpreterRuntimeContext context){
        if( _self.lhs.eval(context) ==  _self.rhs.eval(context)) return 1
        else return 0
    }
}

@Aspect(className=Greater)
class GreaterAspect extends ExpressionAspect {
    def Integer eval(InterpreterRuntimeContext context){
        if( _self.lhs.eval(context) >  _self.rhs.eval(context)) return 1
        else return 0
    }
}

package fr.inria.sed.logo.k3dsa.logo.vm.aspects

import fr.inria.diverse.k3.al.annotationprocessor.Aspect

import fr.inria.sed.logo.vm.model.vm.Turtle
import fr.inria.sed.logo.vm.model.vm.VmFactory

@Aspect(className=Turtle)
class TurtleAspect {

    def void rotate(Integer angle) {
        _self.heading = (_self.heading + angle) % 360
    }

    def void move(double dx, double dy){
        // create new Point for destination
        val point = VmFactory.eINSTANCE.createPoint
        point.x = _self.position.x + dx
        point.y = _self.position.y + dy
        _self.reachedPoints.add(point)

        if(!_self.penUp){
            val drawnSegment = VmFactory.eINSTANCE.createSegment
            drawnSegment.origin = _self.position
            drawnSegment.destination = point
            _self.segments.add(drawnSegment)
        }
        _self.position = point
    }

    def void forward(Integer steps){
        val headingAsRadian = Math.toRadians(_self.heading)
        _self.move(_self.scale(steps, Math.sin(headingAsRadian)), _self.scale(steps, Math.cos(headingAsRadian)))
    }

    /**
     * scale the "steps" expressed using integer by a factor
     */
    def double scale(Integer steps, Double factor){
        return (steps.doubleValue * factor) as Double
    }
}

import static extension fr.inria.sed.logo.k3dsa.logo.vm.aspects.TurtleAspect.*

@Aspect(className=Forward)
class ForwardAspect extends PrimitiveInstructionAspect {
    @Step
    def void run(InterpreterRuntimeContext context){
        context.turtle.forward(_self.steps.eval(context))
    }
}
@Aspect(className=Forward)
class BackwardAspect extends PrimitiveInstructionAspect {
    @Step
    def void run(InterpreterRuntimeContext context){
        context.turtle.forward(- _self.steps.eval(context))
    }
}
@Aspect(className=Left)
class LeftAspect extends PrimitiveInstructionAspect {
    @Step
    def void run(InterpreterRuntimeContext context){
        context.turtle.rotate(- _self.angle.eval(context))
    }
}

@Aspect(className=Right)
class RightAspect extends PrimitiveInstructionAspect {
    @Step
    def void run(InterpreterRuntimeContext context){
        context.turtle.rotate(_self.angle.eval(context))
    }
}

package fr.inria.sed.logo.design.services;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.gemoc.executionframework.extensions.sirius.services.AbstractGemocAnimatorServices;

public class LogoblockdiagramAnimatorServices extends AbstractGemocAnimatorServices {

    @Override
    protected List<StringCouple> getRepresentationRefreshList() {
        final List<StringCouple> res = new ArrayList<StringCouple>();
        res.add(new StringCouple("LogoBlockDiagram", "Animation"));
        return res;
    }
}