public override Value InvokeMethod(String name, List<Value> param) {
switch (name) {
case "getVertexCount":
return new Value(mesh.Vertices.Count, ValType.Integer);
case "getVertex":
if (Value.TypeCompare(param, ValType.Integer)) {
return new Value(new VertexClass(mesh.Vertices[param[0].IntValue]), ValType.Object);
} else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "getEdgeCount":
return new Value(mesh.Edges.Count, ValType.Integer);
case "getEdge":
if (Value.TypeCompare(param, ValType.Integer)) {
return new Value(new EdgeClass(mesh.Edges[param[0].IntValue]), ValType.Object);
} else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "getFaceCount":
return new Value(mesh.Faces.Count, ValType.Integer);
case "getFace":
if (Value.TypeCompare(param, ValType.Integer)) {
return new Value(new FaceClass(mesh.Faces[param[0].IntValue]), ValType.Object);
} else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
default:
throw new CompilerException(-1, 314, Name, name);
}
}
public override object CreateNewInstance(List<Elements.Value> parameters)
{
ListFactory<Visual> layerObjects = new List<Visual>();
foreach (Elements.Value parameter in parameters) {
layerObjects.Add((Visual)parameter.ObjectValue);
}
return new LayerFactory(layerObjects);
}
public override object CreateInstance(List<Elements.Value> parameters)
{
List<AbstractVisualClass> LayerGenerators = new List<AbstractVisualClass>();
foreach (Elements.Value parameter in parameters) {
LayerGenerators.Add((AbstractVisualClass)parameter.ObjectValue);
}
return new LayerClass(LayerGenerators);
}
public InvokeFunctionNode(String objectVar, List<AbstractNode> indexes, String funcName,
List<AbstractNode> parameters, Scope scope, int line)
{
this.funcName = funcName;
this.parameters = parameters != null ? parameters : new List<AbstractNode>();
this.objectVar = objectVar;
this.scope = scope;
this.line = line;
}
public LayerGenerator(List<AbstractVisualClass> layerClasses)
{
List<AbstractVisualGenerator> LayerGeneratorsTemp = new List<AbstractVisualGenerator>();
foreach (AbstractVisualClass obj in layerClasses)
{
LayerGeneratorsTemp.Add(obj.Object);
}
this.LayerGenerators = LayerGeneratorsTemp;
}
public Layer(List<Visual> layerClasses)
{
ListFactory<Sprite> layerObjectsTemp = new List<Sprite>();
foreach (Visual obj in layerClasses)
{
layerObjectsTemp.Add(obj.Object);
}
this.layerObjects = layerObjectsTemp;
}
public override object CreateInstance(List<Value> param)
{
if (Value.TypeCompare(param, ValType.String)) return new SpriteClass(param[0].StringValue);
else if (Value.TypeCompare(param, ValType.String, ValType.Layer))
return new SpriteClass(param[0].StringValue, param[1].StringValue);
else if (Value.TypeCompare(param, ValType.String, ValType.Layer, ValType.Origin))
return new SpriteClass(param[0].StringValue, param[1].StringValue, param[2].StringValue);
else throw new CompilerException(-1, 312);
}
public InvokeFunctionNode(String funcName, List<AbstractNode> parameters, int line)
{
// It's checked weather or not the function name itself exists in order to avoid typos at an early state
if (!LibraryManager.Instance.IsFunctionKnown(funcName) && !GlobalMemory.Instance.IsFunctionKnown(funcName))
{
throw new CompilerException(line, 301, funcName);
}
this.funcName = funcName;
this.parameters = parameters != null ? parameters : new List<AbstractNode>();
this.line = line;
}
public override object CreateNewInstance(List<Value> param)
{
if (Value.TypeCompare(param, ValType.String, ValType.Integer, ValType.Integer))
return new AnimationFactory(param[0].StringValue, param[1].IntValue, param[2].IntValue);
else if (Value.TypeCompare(param, ValType.String, ValType.Layer, ValType.Integer, ValType.Integer))
return new AnimationFactory(param[0].StringValue, param[1].StringValue, param[2].IntValue,
param[3].IntValue);
else if (Value.TypeCompare(param, ValType.String, ValType.Layer, ValType.Origin, ValType.Integer,
ValType.Integer))
return new AnimationFactory(param[0].StringValue, param[1].StringValue, param[2].StringValue,
param[3].IntValue, param[4].IntValue);
else if (Value.TypeCompare(param, ValType.String, ValType.Layer, ValType.Origin, ValType.Integer,
ValType.Integer, ValType.LoopType))
return new AnimationFactory(param[0].StringValue, param[1].StringValue, param[2].StringValue,
param[3].IntValue, param[4].IntValue, param[5].StringValue);
else throw new CompilerException(-1, 312);
}
public override Value InvokeMethod(string name, List<Value> param) {
switch (name) {
case "getVertexCount":
return new Value(face.VertexIndices.Count, ValType.Integer);
case "getVertex":
if (Value.TypeCompare(param, ValType.Integer)) {
return new Value(new VertexClass(face.getVertex(param[0].IntValue)), ValType.Object);
} else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "getVertexIndex":
if (Value.TypeCompare(param, ValType.Integer)) {
return new Value(face.VertexIndices[param[0].IntValue], ValType.Integer);
} else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
default:
throw new CompilerException(-1, 314, Name, name);
}
}
/// <summary>
/// Returns the class
/// </summary>
/// <param name="name"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public object GetClass(string name, List<Value> parameters)
{
// look if the class exists
if (classes.ContainsKey(name))
{
try
{
return classes[name].CreateInstance(parameters);
}
catch (CompilerException ce)
{
if (ce.ErrorCode == 312)
{
ce.SetArguments(name, Value.PrintTypeList(parameters));
}
throw ce;
}
}
else
{
throw new CompilerException(-1, 311, name, Value.PrintTypeList(parameters));
}
}
public override Value InvokeMethod(String name, List<Value> param)
{
switch (name)
{
case "fade":
if (Value.TypeCompare(param, ValType.Double))
{
visualObject.fade(param[0].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Double))
{
visualObject.fade(param[0].IntValue, param[1].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double))
{
visualObject.fade(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
param[3].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Double,
ValType.Double))
{
visualObject.fade(param[0].IntValue, param[1].IntValue, param[2].IntValue,
param[3].DoubleValue, param[4].DoubleValue);
return Value.VOID;
}
else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "scale":
if (Value.TypeCompare(param, ValType.Double))
{
visualObject.scale(param[0].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Double))
{
visualObject.scale(param[0].IntValue, param[1].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double))
{
visualObject.scale(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
param[3].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Double,
ValType.Double))
{
visualObject.scale(param[0].IntValue, param[1].IntValue, param[2].IntValue,
param[3].DoubleValue, param[4].DoubleValue);
return Value.VOID;
}
else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "rotate":
if (Value.TypeCompare(param, ValType.Double))
{
visualObject.rotate(param[0].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Double))
{
visualObject.rotate(param[0].IntValue, param[1].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double))
{
visualObject.rotate(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
param[3].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Double,
ValType.Double))
{
visualObject.rotate(param[0].IntValue, param[1].IntValue, param[2].IntValue,
param[3].DoubleValue, param[4].DoubleValue);
return Value.VOID;
}
else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "moveX":
if (Value.TypeCompare(param, ValType.Double))
{
visualObject.moveX(param[0].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Double))
{
visualObject.moveX(param[0].IntValue, param[1].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double))
{
visualObject.moveX(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
param[3].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Double,
ValType.Double))
{
visualObject.moveX(param[0].IntValue, param[1].IntValue, param[2].IntValue,
param[3].DoubleValue, param[4].DoubleValue);
return Value.VOID;
}
else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "moveY":
if (Value.TypeCompare(param, ValType.Double))
{
visualObject.moveY(param[0].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Double))
{
visualObject.moveY(param[0].IntValue, param[1].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double))
{
visualObject.moveY(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
param[3].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Double,
ValType.Double))
{
visualObject.moveY(param[0].IntValue, param[1].IntValue, param[2].IntValue,
param[3].DoubleValue, param[4].DoubleValue);
return Value.VOID;
}
else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "move":
if (Value.TypeCompare(param, ValType.Integer, ValType.Integer))
{
visualObject.move(param[0].IntValue, param[1].IntValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer))
{
visualObject.move(param[0].IntValue, param[1].IntValue, param[2].IntValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Integer,
ValType.Integer, ValType.Integer))
{
visualObject.move(param[0].IntValue, param[1].IntValue, param[2].IntValue, param[3].IntValue,
param[4].IntValue, param[5].IntValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer,
ValType.Integer, ValType.Integer, ValType.Integer, ValType.Integer))
{
visualObject.move(param[0].IntValue, param[1].IntValue, param[2].IntValue,
param[3].IntValue, param[4].IntValue, param[5].IntValue,
param[6].IntValue);
return Value.VOID;
}
else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "scaleVec":
if (Value.TypeCompare(param, ValType.Double, ValType.Double))
{
visualObject.scaleVec(param[0].DoubleValue, param[1].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Double, ValType.Double))
{
visualObject.scaleVec(param[0].IntValue, param[1].DoubleValue, param[2].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double,
ValType.Double, ValType.Double))
{
visualObject.scaleVec(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
param[3].DoubleValue, param[4].DoubleValue, param[5].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer,
ValType.Double, ValType.Double, ValType.Double, ValType.Double))
{
visualObject.scaleVec(param[0].IntValue, param[1].IntValue, param[2].IntValue,
param[3].DoubleValue, param[4].DoubleValue, param[5].DoubleValue,
param[6].DoubleValue);
return Value.VOID;
}
else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "color":
if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer))
{
visualObject.color(param[0].IntValue, param[1].IntValue, param[2].IntValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Integer))
{
visualObject.color(param[0].IntValue, param[1].IntValue, param[2].IntValue,
param[3].IntValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer,
ValType.Integer, ValType.Integer, ValType.Integer, ValType.Integer,
ValType.Integer))
{
visualObject.color(param[0].IntValue, param[1].IntValue, param[2].IntValue,
param[3].IntValue, param[4].IntValue, param[5].IntValue,
param[6].IntValue, param[7].IntValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer,
ValType.Integer, ValType.Integer, ValType.Integer, ValType.Integer,
ValType.Integer, ValType.Integer))
{
visualObject.color(param[0].IntValue, param[1].IntValue, param[2].IntValue,
param[3].IntValue, param[4].IntValue, param[5].IntValue,
param[6].IntValue, param[7].IntValue, param[8].IntValue);
return Value.VOID;
}
else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "colorHsv":
case "colorHsb":
if (Value.TypeCompare(param, ValType.Integer, ValType.Double, ValType.Double)) {
visualObject.colorHsb(param[0].DoubleValue, param[1].DoubleValue, param[2].DoubleValue);
return Value.VOID;
} else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double)) {
visualObject.colorHsb(param[0].IntValue, param[1].DoubleValue, param[2].DoubleValue,
param[3].DoubleValue);
return Value.VOID;
} else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer,
ValType.Double, ValType.Double, ValType.Integer, ValType.Double,
ValType.Double)) {
visualObject.colorHsb(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
param[3].DoubleValue, param[4].DoubleValue, param[5].DoubleValue,
param[6].DoubleValue, param[7].DoubleValue);
return Value.VOID;
} else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer,
ValType.Double, ValType.Double, ValType.Double, ValType.Double,
ValType.Double, ValType.Double)) {
visualObject.colorHsb(param[0].IntValue, param[1].IntValue, param[2].IntValue,
param[3].DoubleValue, param[4].DoubleValue, param[5].DoubleValue,
param[6].DoubleValue, param[7].DoubleValue, param[8].DoubleValue);
return Value.VOID;
} else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "additive":
if (Value.TypeCompare(param, ValType.Integer, ValType.Integer)) {
visualObject.additive(param[0].IntValue, param[1].IntValue);
return Value.VOID;
} else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "flipH":
if (Value.TypeCompare(param, ValType.Integer, ValType.Integer)) {
visualObject.flipH(param[0].IntValue, param[1].IntValue);
return Value.VOID;
} else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "flipV":
if (Value.TypeCompare(param, ValType.Integer, ValType.Integer)) {
visualObject.flipV(param[0].IntValue, param[1].IntValue);
return Value.VOID;
} else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "startLoop":
if (Value.TypeCompare(param, ValType.Integer, ValType.Integer))
{
visualObject.startLoop(param[0].IntValue, param[1].IntValue);
return Value.VOID;
}
else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "startTriggerLoop":
if (Value.TypeCompare(param, ValType.LoopTrigger, ValType.Integer, ValType.Integer))
{
visualObject.startTriggerLoop(param[0].StringValue, param[1].IntValue, param[2].IntValue);
return Value.VOID;
}
else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "endLoop":
if (param.Count == 0)
{
visualObject.endLoop();
return Value.VOID;
}
else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
default:
throw new CompilerException(-1, 314, Name, name);
}
//TODO: Exception
throw new Exception();
}
public override object CreateInstance(List<Value> param)
{
return new Value(param, ValType.List);
//else throw new CompilerException(-1, 312);
}
public abstract object CreateNewInstance(List<Value> parameters);
public abstract Value InvokeMethod(String name, List<Value> parameters);
public override object CreateInstance(List<Value> param) {
if (Value.TypeCompare(param, ValType.String))
return new MeshClass(param[0].StringValue);
else
throw new CompilerException(-1, 312);
}
public LayerClass(List<AbstractVisualClass> LayerGenerators)
{
this.LayerGenerators = LayerGenerators;
visualObject = new LayerGenerator(LayerGenerators);
}
public override Value InvokeMethod(string name, List<Value> parameters) {
switch (name) {
case "getX":
return new Value(vertex.X, ValType.Double);
case "getY":
return new Value(vertex.Y, ValType.Double);
case "getZ":
return new Value(vertex.Z, ValType.Double);
default:
throw new CompilerException(-1, 314, Name, name);
}
}
public override Value InvokeMethod(String name, List<Value> param)
{
throw new CompilerException(-1, 314, Name, name);
}
public LayerFactory(List<Visual> layerObjects)
{
this.layerObjects = layerObjects;
Sprite = new LayerFactory(layerObjects);
}
public override object CreateInstance(List<Value> parameters) {
// This should never be called
throw new NotSupportedException();
}
protected override Value Invoke()
{
if (objectVar != null && scope != null)
{
var values = new List<Value>();
foreach (AbstractNode node in parameters)
{
values.Add(node.Evaluate());
}
Value resolvedValue = scope.Resolve(objectVar);
if (resolvedValue == null)
{
throw new CompilerException(line, 211, objectVar);
}
if (resolvedValue.Type == ValType.Object)
{
try
{
AbstractClass objectInstance = resolvedValue.ObjectValue;
return objectInstance.InvokeMethod(funcName, values);
}
catch (CompilerException ce)
{
if (ce.ErrorCode == 314)
{
if (GlobalMemory.Instance.IsFunctionKnown(funcName))
{
Function function = GlobalMemory.Instance.GetFunction(funcName, values);
if (function is UserFunction)
{
GlobalMemory.Instance.AddCallToStack(new CallItem(funcName, Line));
Value returnValue = ((UserFunction) function).Invoke(resolvedValue, values);
GlobalMemory.Instance.PopLastCall();
return returnValue;
}
else
{
throw;
}
}
else
{
throw;
}
}
else
{
throw;
}
}
}
throw new CompilerException(line, 316, resolvedValue.TypeString);
}
else
{
var values = new List<Value>();
foreach (AbstractNode node in parameters)
{
values.Add(node.Evaluate());
}
Function function;
if (LibraryManager.Instance.IsFunctionKnown(funcName))
{
function = LibraryManager.Instance.GetFunction(funcName, values);
return function.Invoke(values);
}
else
{
GlobalMemory.Instance.AddCallToStack(new CallItem(funcName, Line));
function = GlobalMemory.Instance.GetFunction(funcName, values);
Value returnValue = function.Invoke(values);
GlobalMemory.Instance.PopLastCall();
return returnValue;
}
}
}
public override Value InvokeMethod(String name, List<Value> param)
{
switch (name)
{
case "fade":
if (Value.TypeCompare(param, ValType.Double))
{
Sprite.fade(param[0].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Double))
{
Sprite.fade(param[0].IntValue, param[1].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double))
{
Sprite.fade(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
param[3].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Double,
ValType.Double))
{
Sprite.fade(param[0].IntValue, param[1].IntValue, param[2].IntValue,
param[3].DoubleValue, param[4].DoubleValue);
return Value.VOID;
}
else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "scale":
if (Value.TypeCompare(param, ValType.Double))
{
Sprite.scale(param[0].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Double))
{
Sprite.scale(param[0].IntValue, param[1].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double))
{
Sprite.scale(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
param[3].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Double,
ValType.Double))
{
Sprite.scale(param[0].IntValue, param[1].IntValue, param[2].IntValue,
param[3].DoubleValue, param[4].DoubleValue);
return Value.VOID;
}
else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "rotate":
if (Value.TypeCompare(param, ValType.Double))
{
Sprite.rotate(param[0].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Double))
{
Sprite.rotate(param[0].IntValue, param[1].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double))
{
Sprite.rotate(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
param[3].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Double,
ValType.Double))
{
Sprite.rotate(param[0].IntValue, param[1].IntValue, param[2].IntValue,
param[3].DoubleValue, param[4].DoubleValue);
return Value.VOID;
}
else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "moveX":
if (Value.TypeCompare(param, ValType.Double))
{
Sprite.moveX(param[0].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Double))
{
Sprite.moveX(param[0].IntValue, param[1].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double))
{
Sprite.moveX(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
param[3].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Double,
ValType.Double))
{
Sprite.moveX(param[0].IntValue, param[1].IntValue, param[2].IntValue,
param[3].DoubleValue, param[4].DoubleValue);
return Value.VOID;
}
else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "moveY":
if (Value.TypeCompare(param, ValType.Double))
{
Sprite.moveY(param[0].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Double))
{
Sprite.moveY(param[0].IntValue, param[1].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double))
{
Sprite.moveY(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
param[3].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Double,
ValType.Double))
{
Sprite.moveY(param[0].IntValue, param[1].IntValue, param[2].IntValue,
param[3].DoubleValue, param[4].DoubleValue);
return Value.VOID;
}
else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "move":
if (Value.TypeCompare(param, ValType.Integer, ValType.Integer))
{
Sprite.move(param[0].IntValue, param[1].IntValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer))
{
Sprite.move(param[0].IntValue, param[1].IntValue, param[2].IntValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Integer,
ValType.Integer, ValType.Integer))
{
Sprite.move(param[0].IntValue, param[1].IntValue, param[2].IntValue, param[3].IntValue,
param[4].IntValue, param[5].IntValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer,
ValType.Integer, ValType.Integer, ValType.Integer, ValType.Integer))
{
Sprite.move(param[0].IntValue, param[1].IntValue, param[2].IntValue,
param[3].IntValue, param[4].IntValue, param[5].IntValue,
param[6].IntValue);
return Value.VOID;
}
else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "scaleVec":
if (Value.TypeCompare(param, ValType.Double, ValType.Double))
{
Sprite.scaleVec(param[0].DoubleValue, param[1].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Double, ValType.Double))
{
Sprite.scaleVec(param[0].IntValue, param[1].DoubleValue, param[2].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double,
ValType.Double, ValType.Double))
{
Sprite.scaleVec(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
param[3].DoubleValue, param[4].DoubleValue, param[5].DoubleValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer,
ValType.Double, ValType.Double, ValType.Double, ValType.Double))
{
Sprite.scaleVec(param[0].IntValue, param[1].IntValue, param[2].IntValue,
param[3].DoubleValue, param[4].DoubleValue, param[5].DoubleValue,
param[6].DoubleValue);
return Value.VOID;
}
else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
case "color":
if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer))
{
Sprite.color(param[0].IntValue, param[1].IntValue, param[2].IntValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Integer))
{
Sprite.color(param[0].IntValue, param[1].IntValue, param[2].IntValue,
param[3].IntValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer,
ValType.Integer, ValType.Integer, ValType.Integer, ValType.Integer,
ValType.Integer))
{
Sprite.color(param[0].IntValue, param[1].IntValue, param[2].IntValue,
param[3].IntValue, param[4].IntValue, param[5].IntValue,
param[6].IntValue, param[7].IntValue);
return Value.VOID;
}
else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer,
ValType.Integer, ValType.Integer, ValType.Integer, ValType.Integer,
ValType.Integer, ValType.Integer))
{
Sprite.color(param[0].IntValue, param[1].IntValue, param[2].IntValue,
param[3].IntValue, param[4].IntValue, param[5].IntValue,
param[6].IntValue, param[7].IntValue, param[8].IntValue);
return Value.VOID;
}
else
throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
default:
throw new CompilerException(-1, 314, Name, name);
}
//TODO: Exception
throw new Exception();
}
public Function GetFunction(string name, List<Value> parameters)
{
// look if the function exists
if (functions.ContainsKey(name))
{
try
{
return functions[name];
}
catch (CompilerException ce)
{
if (ce.ErrorCode == 312)
{
ce.SetArguments(name, Value.PrintTypeList(parameters));
}
throw ce;
}
}
else
{
throw new CompilerException(-1, 311, name, Value.PrintTypeList(parameters));
}
}
public override Value InvokeMethod(string name, List<Value> parameters) {
switch (name) {
case "getV0":
case "getVertex0":
return new Value(new VertexClass(edge.V0), ValType.Object);
case "getV1":
case "getVertex1":
return new Value(new VertexClass(edge.V1), ValType.Object);
case "getV0Index":
case "getVertex0Index":
return new Value(edge.V0Index, ValType.Integer);
case "getV1Index":
case "getVertex1Index":
return new Value(edge.V0Index, ValType.Integer);
default:
throw new CompilerException(-1, 314, Name, name);
}
}
