public override DmlObject CallDynamic(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
var time = (DmlObject)(stack.Pop());
var period = (DmlObject)(stack.Pop());
var start = (DmlObject)(stack.Pop());
var max = (DmlObject)(stack.Pop());
var min = (DmlObject)(stack.Pop());
if (min.Type != DmlType.Number)
throw DmlSyntaxError.BadArgumentType(Name, 1, DmlType.Number, min.Type);
if (max.Type != DmlType.Number)
throw DmlSyntaxError.BadArgumentType(Name, 2, DmlType.Number, max.Type);
if (start.Type != DmlType.Number)
throw DmlSyntaxError.BadArgumentType(Name, 3, DmlType.Number, start.Type);
if (period.Type != DmlType.Number)
throw DmlSyntaxError.BadArgumentType(Name, 4, DmlType.Number, period.Type);
if (time.Type != DmlType.Number)
throw DmlSyntaxError.BadArgumentType(Name, 5, DmlType.Number, time.Type);
return new DmlObject(DmlType.Number, _squareWave(
(double)(min.Value),
(double)(max.Value),
(double)(start.Value),
(double)(period.Value),
(double)(time.Value)
));
}
public override DmlObject CallDynamic(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
var list = new List<DmlObject>();
for (int i = 0; i < argCount; i++)
list.Add(stack.Pop());
list.Reverse(); // We have to reverse it since we pop the objects from the stack in reverse order.
return new DmlObject(DmlType.List, list);
}
public override DmlObject CallDynamic(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
DmlObject top = stack.Pop();
if (top.Type != DmlType.Vector)
throw DmlSyntaxError.BadArgumentType(Name, 1, DmlType.Vector, top.Type);
Vector2 vec = (Vector2)(top.Value);
return new DmlObject(DmlType.Number, Math.Atan2(vec.Y, vec.X));
}
public void SetVar(string name, DmlObject obj)
{
if (name[0] == '"')
name = name.Substring(1);
if (name[name.Length - 1] == '"')
name = name.Substring(0, name.Length - 1);
BoundVars[name] = obj;
}
public override DmlObject CallDynamic(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
DmlObject timeObj = stack.Pop();
if (timeObj.Type != DmlType.Number)
throw DmlSyntaxError.BadArgumentType(Name, 1, DmlType.Number, timeObj.Type);
double time = (double)(timeObj.Value);
double ltime = ((DmlBullet)bullet.Value).LocalTime;
return new DmlObject(DmlType.Bool, ltime >= time);
}
public override DmlObject CallTypeSafe(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
var time = (double)(stack.Pop().Value);
var period = (double)(stack.Pop().Value);
var start = (double)(stack.Pop().Value);
var max = (double)(stack.Pop().Value);
var min = (double)(stack.Pop().Value);
return new DmlObject(DmlType.Number, _squareWave(min, max, start, period, time));
}
public DmlObject Instantiate(Vector2 Position, DmlSystem system)
{
DmlBullet bullet = new DmlBullet(Position, this);
DmlObject bulletObject = new DmlObject(DmlType.Bullet, bullet);
bullet.SetObject(bulletObject);
// Execute the initialziation code.
Init.Execute(bulletObject, system);
return bulletObject;
}
public void Execute(DmlObject bullet, DmlSystem system)
{
// The command stack.
Stack<DmlObject> stack = new Stack<DmlObject>();
// The variables local to this code block.
Dictionary<string, DmlObject> locals = new Dictionary<string, DmlObject>();
while (currentPosition < Instructions.Length)
Instructions[currentPosition++].Perform(this, stack, locals, bullet, system);
currentPosition = 0;
}
public void Execute(DmlObject bullet, DmlSystem system)
{
// The command stack.
Stack<DmlObject> stack = new Stack<DmlObject>();
// The variables local to this code block.
Dictionary<string, DmlObject> locals = new Dictionary<string, DmlObject>();
while (currentPosition < Instructions.Length)
Instructions[currentPosition++].Perform(this, stack, locals, bullet, system);
currentPosition = 0;
}
public void SetVar(string name, DmlObject obj)
{
if (name[0] == '"')
{
name = name.Substring(1);
}
if (name[name.Length - 1] == '"')
{
name = name.Substring(0, name.Length - 1);
}
BoundVars[name] = obj;
}
public override DmlObject CallDynamic(int argCount, Stack <DmlObject> stack, DmlObject bullet, DmlSystem system)
{
var option = new DmlObject(DmlType.Option, null);
DmlObject nextArg;
for (int i = 0; i < argCount; i++)
{
nextArg = stack.Pop();
option.BoundVars[Parameters[i]] = nextArg;
}
return(option);
}
public DmlObject Evaluate(DmlObject bullet, DmlSystem system)
{
// The command stack.
Stack<DmlObject> stack = new Stack<DmlObject>();
// The variables local to this code block.
Dictionary<string, DmlObject> locals = new Dictionary<string, DmlObject>();
while (currentPosition < Instructions.Length)
Instructions[currentPosition++].Perform(this, stack, locals, bullet, system);
currentPosition = 0;
return stack.Count == 0 ? null : stack.Pop();
}
public DmlObject Evaluate(DmlObject bullet, DmlSystem system)
{
// The command stack.
Stack<DmlObject> stack = new Stack<DmlObject>();
// The variables local to this code block.
Dictionary<string, DmlObject> locals = new Dictionary<string, DmlObject>();
while (currentPosition < Instructions.Length)
Instructions[currentPosition++].Perform(this, stack, locals, bullet, system);
currentPosition = 0;
return stack.Count == 0 ? null : stack.Pop();
}
public override DmlObject CallDynamic(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
DmlObject second = stack.Pop();
DmlObject first = stack.Pop();
switch (first.Type)
{
case DmlType.Number:
switch (second.Type)
{
case DmlType.Number:
return new DmlObject(DmlType.Number, Math.Atan2((double)first.Value, (double)second.Value));
default:
throw DmlSyntaxError.BadArgumentType(Name, 2, DmlType.Number, second.Type);
}
default:
throw DmlSyntaxError.BadArgumentType(Name, 1, DmlType.Number, first.Type);
}
}
public override DmlObject CallDynamic(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
DmlObject top = stack.Pop();
if (top.Type != DmlType.Vector)
throw DmlSyntaxError.BadArgumentType(Name, 1, DmlType.Vector, top.Type);
Vector2 vec = (Vector2)(top.Value);
return new DmlObject(DmlType.Number, (double)Vector2.DistanceSquared(vec, Vector2.Zero));
}
public override DmlObject CallTypeSafe(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
double amt = (double)(stack.Pop().Value);
Vector2 end = (Vector2)(stack.Pop().Value);
Vector2 start = (Vector2)(stack.Pop().Value);
return new DmlObject(DmlType.Vector, Vector2.Lerp(start, end, (float)amt));
}
public override DmlObject CallDynamic(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
DmlObject amtObj = stack.Pop();
DmlObject endObj = stack.Pop();
DmlObject startObj = stack.Pop();
if (startObj.Type != DmlType.Vector)
throw DmlSyntaxError.BadArgumentType(Name, 1, DmlType.Vector, startObj.Type);
if (endObj.Type != DmlType.Vector)
throw DmlSyntaxError.BadArgumentType(Name, 2, DmlType.Vector, endObj.Type);
if (amtObj.Type != DmlType.Number)
throw DmlSyntaxError.BadArgumentType(Name, 2, DmlType.Number, amtObj.Type);
double amt = (double)(amtObj.Value);
Vector2 end = (Vector2)(endObj.Value);
Vector2 start = (Vector2)(startObj.Value);
return new DmlObject(DmlType.Vector, Vector2.Lerp(start, end, (float)amt));
}
public override DmlObject CallTypeSafe(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
Vector2 top = (Vector2)(stack.Pop().Value);
return new DmlObject(DmlType.Number, 180/Math.PI*Math.Atan2(top.Y, top.X));
}
public override DmlObject CallTypeSafe(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
double end = (double)(stack.Pop().Value);
double start = (double)(stack.Pop().Value);
double ltime = ((DmlBullet)bullet.Value).LocalTime;
return new DmlObject(DmlType.Bool, start <= ltime && ltime < end);
}
public override DmlObject CallTypeSafe(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
double y = (double)(stack.Pop().Value);
double x = (double)(stack.Pop().Value);
return new DmlObject(DmlType.Vector, new Vector2((float)x, (float)y));
}
public override DmlObject CallTypeSafe(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
Vector2 top = (Vector2)(stack.Pop().Value);
top.Normalize();
return new DmlObject(DmlType.Vector, top);
}
public override DmlObject CallDynamic(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
DmlObject second = stack.Pop();
DmlObject first = stack.Pop();
if (first.Type != DmlType.Vector)
throw DmlSyntaxError.BadArgumentType(Name, 1, DmlType.Vector, first.Type);
if (second.Type != DmlType.Number)
throw DmlSyntaxError.BadArgumentType(Name, 1, DmlType.Number, second.Type);
double angle = Math.PI/180*(double)(second.Value);
Vector2 vec = (Vector2)(first.Value);
float x = vec.X;
float y = vec.Y;
float cos = (float)Math.Cos(angle);
float sin = (float)Math.Sin(angle);
var newVec = new Vector2(x * cos - y * sin, x * sin + y * cos);
newVec.Normalize(); // This avoids rounding errors that cause the bullets to eventually speed up.
return new DmlObject(DmlType.Vector, newVec);
}
public override DmlObject CallTypeSafe(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
double angle = Math.PI/180*(double)(stack.Pop().Value);
return new DmlObject(DmlType.Vector, new Vector2((float)Math.Cos(angle), (float)Math.Sin(angle)));
}
public override DmlObject CallDynamic(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
DmlObject timeObj = stack.Pop();
if (timeObj.Type != DmlType.Number)
throw DmlSyntaxError.BadArgumentType(Name, 1, DmlType.Number, timeObj.Type);
double time = (double)(timeObj.Value);
double ltime = system.GlobalTime;
return new DmlObject(DmlType.Bool, time <= ltime && ltime < time + Globals.deltaTime);
}
/// <summary>
/// Call this function. Unlike CallDynamic, this assumes the types on the stack are safe (i.e.
/// they satisfy CompatibleWithArgTypes.
///
/// By default this just defers to CallDynamic, but this can be override in child classes. The
/// point is that CallTypeSafe is supposed to be faster than CallDynamic because it doesn't have
/// to check the types of the items on the stack, it can instead directly cast the DmlObjects
/// to their C# types.
/// </summary>
/// <param name="argCount"></param>
/// <param name="stack"></param>
/// <param name="bullet"></param>
/// <param name="system"></param>
/// <returns></returns>
public virtual DmlObject CallTypeSafe(int argCount, Stack <DmlObject> stack, DmlObject bullet, DmlSystem system)
{
return(CallDynamic(argCount, stack, bullet, system));
}
public override DmlObject CallDynamic(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
DmlObject top;
string msg = "";
for (int i = 0; i < argCount; i++)
{
top = stack.Pop();
msg += top.Value.ToString();
if (i != argCount - 1)
msg += " ";
}
Console.WriteLine(msg);
return null;
}
public override DmlObject CallTypeSafe(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
Vector2 top = (Vector2)(stack.Pop().Value);
return new DmlObject(DmlType.Number, (double)Vector2.DistanceSquared(top, Vector2.Zero));
}
public override DmlObject CallTypeSafe(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
double start, end, interval, ltime;
switch (argCount)
{
case 1:
interval = (double)(stack.Pop().Value);
ltime = system.GlobalTime;
return new DmlObject(DmlType.Bool, (ltime % (2 * interval)) < interval);
case 3:
end = (double)(stack.Pop().Value);
start = (double)(stack.Pop().Value);
interval = (double)(stack.Pop().Value);
ltime = system.GlobalTime;
double t2 = ltime - start;
return new DmlObject(DmlType.Bool,
(t2 >= 0 && ltime <= end) && (t2 % (2 * interval)) < interval);
default:
return null; // Should never get here.
}
}
/// <summary> /// Call this function. CallDynamic does not assume the types of the objects on the stack are /// safe for use by the function. CallTypeSafe does. /// </summary> /// <param name="argCount"></param> /// <param name="stack"></param> /// <param name="bullet"></param> /// <param name="system"></param> /// <returns></returns> public abstract DmlObject CallDynamic(int argCount, Stack <DmlObject> stack, DmlObject bullet, DmlSystem system);
public override DmlObject CallDynamic(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
DmlObject endObj = stack.Pop();
DmlObject startObj = stack.Pop();
if (startObj.Type != DmlType.Number)
throw DmlSyntaxError.BadArgumentType(Name, 1, DmlType.Number, startObj.Type);
if (endObj.Type != DmlType.Number)
throw DmlSyntaxError.BadArgumentType(Name, 2, DmlType.Number, endObj.Type);
double end = (double)(endObj.Value);
double start = (double)(startObj.Value);
double ltime = ((DmlBullet)bullet.Value).LocalTime;
return new DmlObject(DmlType.Bool, start <= ltime && ltime < end);
}
public override DmlObject CallDynamic(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
DmlObject top = stack.Pop();
if (top.Type != DmlType.Number)
throw DmlSyntaxError.BadArgumentType(Name, 1, DmlType.Number, top.Type);
double angle = Math.PI/180*(double)(top.Value);
return new DmlObject(DmlType.Vector, new Vector2((float)Math.Cos(angle), (float)Math.Sin(angle)));
}
public override DmlObject CallDynamic(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
DmlObject second = stack.Pop();
DmlObject first = stack.Pop();
if (first.Type != DmlType.Number)
throw DmlSyntaxError.BadArgumentType(Name, 1, DmlType.Number, first.Type);
if (second.Type != DmlType.Number)
throw DmlSyntaxError.BadArgumentType(Name, 2, DmlType.Number, second.Type);
double y = (double)(second.Value);
double x = (double)(first.Value);
return new DmlObject(DmlType.Vector, new Vector2((float)x, (float)y));
}
public override DmlObject CallTypeSafe(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
Vector2 top = (Vector2)(stack.Pop().Value);
return new DmlObject(DmlType.Vector, new Vector2(top.Y, -top.X));
}
public override DmlObject CallTypeSafe(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
double time = (double)(stack.Pop().Value);
double ltime = system.GlobalTime;
return new DmlObject(DmlType.Bool, ltime < time);
}
public override DmlObject CallTypeSafe(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
double angle = Math.PI/180*(double)(stack.Pop().Value);
Vector2 vec = (Vector2)(stack.Pop().Value);
float x = vec.X;
float y = vec.Y;
float cos = (float)Math.Cos(angle);
float sin = (float)Math.Sin(angle);
var newVec = new Vector2(x * cos - y * sin, x * sin + y * cos);
newVec.Normalize(); // This avoids rounding errors that cause the bullets to eventually speed up.
return new DmlObject(DmlType.Vector, newVec);
}
public override DmlObject CallDynamic(int argCount, Stack<DmlObject> stack, DmlObject bullet, DmlSystem system)
{
DmlObject intervalObj;
double start, end, interval, ltime;
switch (argCount)
{
case 1:
intervalObj = stack.Pop();
if (intervalObj.Type != DmlType.Number)
throw DmlSyntaxError.BadArgumentType(Name, 1, DmlType.Number, intervalObj.Type);
interval = (double)(stack.Pop().Value);
ltime = system.GlobalTime;
return new DmlObject(DmlType.Bool, (ltime % (2 * interval)) < interval);
case 3:
DmlObject endObj = stack.Pop();
DmlObject startObj = stack.Pop();
intervalObj = stack.Pop();
if (intervalObj.Type != DmlType.Number)
throw DmlSyntaxError.BadArgumentType(Name, 1, DmlType.Number, intervalObj.Type);
if (startObj.Type != DmlType.Number)
throw DmlSyntaxError.BadArgumentType(Name, 2, DmlType.Number, startObj.Type);
if (endObj.Type != DmlType.Number)
throw DmlSyntaxError.BadArgumentType(Name, 3, DmlType.Number, endObj.Type);
end = (double)(stack.Pop().Value);
start = (double)(stack.Pop().Value);
interval = (double)(stack.Pop().Value);
ltime = system.GlobalTime;
double t2 = ltime - start;
return new DmlObject(DmlType.Bool,
(t2 >= 0 && ltime <= end) && (t2 % (2 * interval)) < interval);
default:
return null; // Should never get here.
}
}
