/// <summary>
/// Parse a specified node and bullet into this task
/// </summary>
/// <param name="myNode">the node for this dude</param>
/// <param name="bullet">the bullet this dude is controlling</param>
public override void ParseTasks(Bullet bullet)
{
//set the number of times to repeat this action
var actionNode = Node as ActionNode;
Debug.Assert(null != actionNode);
RepeatNumMax = actionNode.RepeatNum(this, bullet);
//is this an actionref task?
if (ENodeName.actionRef == Node.Name)
{
//add a sub task under this one for the referenced action
var myActionRefNode = Node as ActionRefNode;
//create the action task
var actionTask = new ActionTask(myActionRefNode.ReferencedActionNode, this);
//parse the children of the action node into the task
actionTask.ParseTasks(bullet);
//store the task
ChildTasks.Add(actionTask);
}
//call the base class
base.ParseTasks(bullet);
}
/// <summary>
/// Adds the provided task as a child task.
/// </summary>
/// <param name="childTask"><see cref="ITask"/> to add as a child task.</param>
public virtual void AddChild(ITask childTask)
{
if (childTask == null)
{
throw new ArgumentNullException("childTask");
}
ChildTasks.Add(childTask);
}
public void GetChildren(Tasks parentTask, List <Tasks> tasksFromRepo)
{
var q = tasksFromRepo.Where(w => w.ParentTaskGUID == parentTask.TaskGUID);
foreach (var task in q)
{
ChildTasks.Add(task);
GetChildren(task, tasksFromRepo);
}
}
/// <summary>
/// Parse a specified node and bullet into this task.
/// </summary>
/// <param name="bullet">The bullet this action is controlling.</param>
public override void ParseTasks(Bullet bullet)
{
// Set the number of times to repeat this action
var actionNode = Node as ActionNode;
Debug.Assert(null != actionNode);
RepeatNumMax = actionNode.RepeatNum(this, bullet);
// Check that there is a wait node if the RepeatNumMax is 0 (= infinite)
if (RepeatNumMax == 0)
{
var waitNode = actionNode.ChildNodes.Find(
node => node.Name == NodeName.wait && node.GetValue(this) > 0f
) as WaitNode;
if (waitNode == null)
{
if (actionNode.Name == NodeName.actionRef)
{
Console.WriteLine("Warning: A repeat node is used with an actionRef child, " +
"please make sure that this actionRef contains a wait node " +
"or it will block the program.");
}
else
{
throw new InvalidDataException("You have an infinite loop with no wait node, " +
"this is bad because it will block the program.");
}
}
}
// Is this an actionRef task?
if (Node.Name == NodeName.actionRef)
{
// Add a sub task under this one for the referenced action
var actionRefNode = Node as ActionRefNode;
// Create the action task
if (actionRefNode != null)
{
var actionTask = new ActionTask(actionRefNode.ReferencedActionNode, this);
// Parse the children of the action node into the task
actionTask.ParseTasks(bullet);
// Store the task
ChildTasks.Add(actionTask);
}
}
// Call the base class
base.ParseTasks(bullet);
}
/// <summary>
/// Parse a specified node and bullet into this task
/// </summary>
/// <param name="childNode">the node for this dude</param>
/// <param name="bullet">the bullet this dude is controlling</param>
protected override void ParseChildNode(BulletMLNode childNode, Bullet bullet)
{
Debug.Assert(null != childNode);
Debug.Assert(null != bullet);
switch (childNode.Name)
{
case ENodeName.bulletRef:
{
//Create a task for the bullet ref
if (childNode is BulletRefNode refNode)
{
BulletRefTask = new BulletMLTask(refNode.ReferencedBulletNode, this);
}
//populate the params of the bullet ref
foreach (var node in childNode.ChildNodes)
{
BulletRefTask.ParamList.Add(node.GetValue(this, bullet));
}
BulletRefTask.ParseTasks(bullet);
ChildTasks.Add(BulletRefTask);
}
break;
case ENodeName.bullet:
{
//Create a task for the bullet ref
BulletRefTask = new BulletMLTask(childNode, this);
BulletRefTask.ParseTasks(bullet);
ChildTasks.Add(BulletRefTask);
}
break;
default:
{
//run the node through the base class if we don't want it
base.ParseChildNode(childNode, bullet);
}
break;
}
}
/// <summary>
/// Parse a specified node and bullet into this task
/// </summary>
/// <param name="myNode">the node for this dude</param>
/// <param name="bullet">the bullet this dude is controlling</param>
public override void ParseChildNode(BulletMLNode childNode, Bullet bullet)
{
System.Diagnostics.Debug.Assert(null != childNode);
System.Diagnostics.Debug.Assert(null != bullet);
switch (childNode.Name)
{
case ENodeName.bulletRef:
{
//Create a task for the bullet ref
BulletRefNode refNode = childNode as BulletRefNode;
BulletRefTask = new BulletMLTask(refNode.ReferencedBulletNode, this);
//populate the params of the bullet ref
for (int i = 0; i < childNode.ChildNodes.Count; i++)
{
BulletRefTask.ParamList.Add(childNode.ChildNodes[i].GetValue(this));
}
BulletRefTask.ParseTasks(bullet);
ChildTasks.Add(BulletRefTask);
}
break;
case ENodeName.bullet:
{
//Create a task for the bullet ref
BulletRefTask = new BulletMLTask(childNode, this);
BulletRefTask.ParseTasks(bullet);
ChildTasks.Add(BulletRefTask);
}
break;
default:
{
//run the node through the base class if we don't want it
base.ParseChildNode(childNode, bullet);
}
break;
}
}
/// <summary>
/// Parse a specified node and bullet into this task
/// </summary>
/// <param name="myNode">the node for this dude</param>
/// <param name="bullet">the bullet this dude is controlling</param>
public override void ParseTasks(Bullet bullet)
{
//is this an actionref task?
if (ENodeName.actionRef == Node.Name)
{
//add a sub task under this one for the referenced action
ActionRefNode myActionRefNode = Node as ActionRefNode;
//create the action task
ActionTask actionTask = new ActionTask(myActionRefNode.ReferencedActionNode, this);
//parse the children of the action node into the task
actionTask.ParseTasks(bullet);
//store the task
ChildTasks.Add(actionTask);
}
//call the base class
base.ParseTasks(bullet);
}
/// <summary>
/// Retrieve the bullet or bulletRef nodes from a fire task.
/// </summary>
/// <param name="task">Task to check if has a child bullet or bulletRef node.</param>
/// <param name="bullet">Associated bullet.</param>
private void GetBulletNode(BulletMLTask task, Bullet bullet)
{
if (task == null)
{
return;
}
// Check if there is a bullet or a bulletRef node
var bulletNode = task.Node.GetChild(NodeName.bullet) as BulletNode;
var bulletRefNode = task.Node.GetChild(NodeName.bulletRef) as BulletRefNode;
if (bulletNode != null)
{
// Create a task for the bullet ref
BulletTask = new BulletMLTask(bulletNode, this);
BulletTask.ParseTasks(bullet);
ChildTasks.Add(BulletTask);
}
else if (bulletRefNode != null)
{
// Create a task for the bullet ref
BulletTask = new BulletMLTask(bulletRefNode.ReferencedBulletNode, this);
// Populate the params of the bullet ref
foreach (var node in bulletRefNode.ChildNodes)
{
BulletTask.Params.Add(node.GetValue(this));
}
BulletTask.ParseTasks(bullet);
ChildTasks.Add(BulletTask);
}
else
{
throw new InvalidDataException("A <fire> node must contain a <bullet> or a <bulletRef> node.");
}
}
/// <summary>
/// Parse a specified node and bullet into this task
/// </summary>
/// <param name="childNode">the node for this dude</param>
/// <param name="bullet">the bullet this dude is controlling</param>
protected virtual void ParseChildNode(BulletMLNode childNode, Bullet bullet)
{
Debug.Assert(null != childNode);
Debug.Assert(null != bullet);
//construct the correct type of node
switch (childNode.Name)
{
case ENodeName.repeat:
{
//convert the node to an repeatnode
var myRepeatNode = childNode as RepeatNode;
//create a placeholder bulletmltask for the repeat node
var repeatTask = new RepeatTask(myRepeatNode, this);
//parse the child nodes into the repeat task
repeatTask.ParseTasks(bullet);
//store the task
ChildTasks.Add(repeatTask);
}
break;
case ENodeName.action:
{
//convert the node to an ActionNode
var myActionNode = childNode as ActionNode;
//create the action task
var actionTask = new ActionTask(myActionNode, this);
//parse the children of the action node into the task
actionTask.ParseTasks(bullet);
//store the task
ChildTasks.Add(actionTask);
}
break;
case ENodeName.actionRef:
{
//convert the node to an ActionNode
var myActionNode = childNode as ActionRefNode;
//create the action task
var actionTask = new ActionTask(myActionNode, this);
//add the params to the action task
for (var i = 0; i < childNode.ChildNodes.Count; i++)
{
actionTask.ParamList.Add(childNode.ChildNodes[i].GetValue(this, bullet));
}
//parse the children of the action node into the task
actionTask.ParseTasks(bullet);
//store the task
ChildTasks.Add(actionTask);
}
break;
case ENodeName.changeSpeed:
{
ChildTasks.Add(new ChangeSpeedTask(childNode as ChangeSpeedNode, this));
}
break;
case ENodeName.changeDirection:
{
ChildTasks.Add(new ChangeDirectionTask(childNode as ChangeDirectionNode, this));
}
break;
case ENodeName.fire:
{
//convert the node to a fire node
var myFireNode = childNode as FireNode;
//create the fire task
var fireTask = new FireTask(myFireNode, this);
//parse the children of the fire node into the task
fireTask.ParseTasks(bullet);
//store the task
ChildTasks.Add(fireTask);
}
break;
case ENodeName.fireRef:
{
//convert the node to a fireref node
//create the fire task
if (childNode is FireRefNode myFireNode)
{
var fireTask = new FireTask(myFireNode.ReferencedFireNode, this);
//add the params to the fire task
for (var i = 0; i < childNode.ChildNodes.Count; i++)
{
fireTask.ParamList.Add(childNode.ChildNodes[i].GetValue(this, bullet));
}
//parse the children of the action node into the task
fireTask.ParseTasks(bullet);
//store the task
ChildTasks.Add(fireTask);
}
}
break;
case ENodeName.wait:
{
ChildTasks.Add(new WaitTask(childNode as WaitNode, this));
}
break;
case ENodeName.vanish:
{
ChildTasks.Add(new VanishTask(childNode as VanishNode, this));
}
break;
case ENodeName.accel:
{
ChildTasks.Add(new AccelTask(childNode as AccelNode, this));
}
break;
}
}
/// <summary>
/// Parse a specified node and bullet into this task
/// </summary>
/// <param name="myNode">the node for this dude</param>
/// <param name="bullet">the bullet this dude is controlling</param>
public virtual void Parse(BulletMLNode myNode, Bullet bullet)
{
Debug.Assert(null != myNode);
Debug.Assert(null != bullet);
foreach (BulletMLNode childNode in myNode.ChildNodes)
{
//construct the correct type of node
switch (childNode.Name)
{
case ENodeName.repeat:
{
Parse(childNode, bullet);
}
break;
case ENodeName.action:
{
int repeatNum = 1;
//find how many times to repeat this action
BulletMLNode RepeatNode = childNode.FindParentNode(ENodeName.repeat);
if (null != RepeatNode)
{
repeatNum = (int)RepeatNode.GetChildValue(ENodeName.times, this);
}
BulletMLAction task = new BulletMLAction(repeatNum, myNode, this);
ChildTasks.Add(task);
task.Parse(childNode, bullet);
}
break;
case ENodeName.actionRef:
{
//find the referenced node
BulletMLNode refNode = myNode.GetRootNode().FindLabelNode(childNode.Label, ENodeName.action);
//find how many times to repeat the referenced action
int repeatNum = 1;
BulletMLNode RepeatNode = myNode.FindParentNode(ENodeName.repeat);
if (null != RepeatNode)
{
repeatNum = (int)RepeatNode.GetChildValue(ENodeName.times, this);
}
BulletMLAction task = new BulletMLAction(repeatNum, refNode, this);
ChildTasks.Add(task);
for (int i = 0; i < childNode.ChildNodes.Count; i++)
{
task.ParamList.Add(childNode.ChildNodes[i].GetValue(this));
}
task.Parse(refNode, bullet);
}
break;
case ENodeName.changeSpeed:
{
ChildTasks.Add(new BulletMLChangeSpeed(childNode, this));
}
break;
case ENodeName.changeDirection:
{
ChildTasks.Add(new BulletMLChangeDirection(childNode, this));
}
break;
case ENodeName.fire:
{
ChildTasks.Add(new BulletMLFire(childNode, this));
}
break;
case ENodeName.fireRef:
{
//find the node that was referenced
BulletMLNode refNode = myNode.GetRootNode().FindLabelNode(childNode.Label, ENodeName.fire);
BulletMLFire fire = new BulletMLFire(refNode, this);
ChildTasks.Add(fire);
for (int i = 0; i < childNode.ChildNodes.Count; i++)
{
fire.ParamList.Add(childNode.ChildNodes[i].GetValue(this));
}
}
break;
case ENodeName.wait:
{
ChildTasks.Add(new BulletMLWait(childNode, this));
}
break;
case ENodeName.speed:
{
//speed nodes are special, just pull the value out and set up the bullet
bullet.GetFireData().speedInit = true;
bullet.Velocity = childNode.GetValue(this);
}
break;
case ENodeName.direction:
{
ChildTasks.Add(new BulletMLSetDirection(childNode, this));
}
break;
case ENodeName.vanish:
{
ChildTasks.Add(new BulletMLVanish(childNode, this));
}
break;
case ENodeName.accel:
{
ChildTasks.Add(new BulletMLAccel(childNode, this));
}
break;
}
}
//After all the nodes are read in, initialize the node
Init();
}
/// <summary>
/// Parse a specified node and bullet into this task.
/// </summary>
/// <param name="childNode">The node for this task.</param>
/// <param name="bullet">The bullet this task is controlling.</param>
private void ParseChildNode(BulletMLNode childNode, Bullet bullet)
{
Debug.Assert(null != childNode);
Debug.Assert(null != bullet);
// Construct the correct type of node
switch (childNode.Name)
{
case NodeName.repeat:
{
// Convert the node to an repeatnode
var repeatNode = childNode as RepeatNode;
// Create a placeholder BulletMLTask for the repeat node
var repeatTask = new RepeatTask(repeatNode, this);
// Parse the child nodes into the repeat task
repeatTask.ParseTasks(bullet);
// Store the task
ChildTasks.Add(repeatTask);
}
break;
case NodeName.action:
{
// Convert the node to an ActionNode
var actionNode = childNode as ActionNode;
// Create the action task
var actionTask = new ActionTask(actionNode, this);
// Parse the children of the action node into the task
actionTask.ParseTasks(bullet);
// Store the task
ChildTasks.Add(actionTask);
}
break;
case NodeName.actionRef:
{
// Convert the node to an ActionNode
var actionRefNode = childNode as ActionRefNode;
// Create the action task
var actionTask = new ActionTask(actionRefNode, this);
// Add the params to the action task
for (int i = 0; i < childNode.ChildNodes.Count; i++)
{
actionTask.Params.Add(childNode.ChildNodes[i].GetValue(this));
}
// Parse the children of the action node into the task
actionTask.ParseTasks(bullet);
// Store the task
ChildTasks.Add(actionTask);
}
break;
case NodeName.fire:
{
// Convert the node to a fire node
var fireNode = childNode as FireNode;
// Create the fire task
var fireTask = new FireTask(fireNode, this);
// Parse the children of the fire node into the task
fireTask.ParseTasks(bullet);
// Store the task
ChildTasks.Add(fireTask);
}
break;
case NodeName.fireRef:
{
// Convert the node to a fireRef node
var fireRefNode = childNode as FireRefNode;
// Create the fire task
if (fireRefNode != null)
{
var fireTask = new FireTask(fireRefNode.ReferencedFireNode, this);
// Add the params to the fire task
for (int i = 0; i < childNode.ChildNodes.Count; i++)
{
fireTask.Params.Add(childNode.ChildNodes[i].GetValue(this));
}
// Parse the children of the action node into the task
fireTask.ParseTasks(bullet);
// Store the task
ChildTasks.Add(fireTask);
}
}
break;
case NodeName.changeSpeed:
{
ChildTasks.Add(new ChangeSpeedTask(childNode as ChangeSpeedNode, this));
}
break;
case NodeName.changeDirection:
{
ChildTasks.Add(new ChangeDirectionTask(childNode as ChangeDirectionNode, this));
}
break;
case NodeName.wait:
{
ChildTasks.Add(new WaitTask(childNode as WaitNode, this));
}
break;
case NodeName.vanish:
{
ChildTasks.Add(new VanishTask(childNode as VanishNode, this));
}
break;
case NodeName.accel:
{
ChildTasks.Add(new AccelTask(childNode as AccelNode, this));
}
break;
case NodeName.color:
{
ChildTasks.Add(new ColorTask(childNode as ColorNode, this));
}
break;
case NodeName.changeColor:
{
ChildTasks.Add(new ChangeColorTask(childNode as ChangeColorNode, this));
}
break;
case NodeName.changeScale:
{
ChildTasks.Add(new ChangeScaleTask(childNode as ChangeScaleNode, this));
}
break;
}
}