public void TestCalculationNodes(int leftNumber, int rightNumber, Operator o, int value)
{
INode node = new CalculationNode(GetIntegerNode(leftNumber), GetIntegerNode(rightNumber), o);
Assert.Equal(3, node.Complexity);
Assert.Equal(value, node.Value);
}
private void EnterOperator(Operator @operator)
{
int newValue = Convert.ToInt32(DisplayValue);
_head = Insert(_head, newValue, @operator);
_isEditing = false;
}
public void TestZeros()
{
int leftNumber = 10;
int rightNumber = 0;
CalculationNode calculationNode = new CalculationNode(GetIntegerNode(leftNumber), GetIntegerNode(rightNumber), Operator.Divide);
Assert.False(calculationNode.GivesIntegerResult);
}
private INode CreateCalculationNode(INode left, INode right, Operator o)
{
CalculationNode node = new CalculationNode(left, right, o);
if (node.GivesIntegerResult)
{
return(node);
}
else
{
return(null);
}
}
public void TestNonIntegerDivision(int left, int right, bool shouldThrowException)
{
INode node = new CalculationNode(GetIntegerNode(left), GetIntegerNode(right), Operator.Divide);
Assert.Equal(3, node.Complexity);
if (shouldThrowException)
{
Assert.Equal(-1, node.Value);
}
else
{
Assert.NotEqual(-1, node.Value);
}
}
internal void EnteryKey(char character)
{
switch (character)
{
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case '0':
if (_isEditing && DisplayValue != "0")
{
DisplayValue += character.ToString();
}
else
{
_isEditing = true;
DisplayValue = character.ToString();
}
break;
case '+': EnterOperator(Operator.Add); break;
case '-': EnterOperator(Operator.Subtract); break;
case 'x':
case '*': EnterOperator(Operator.Multiply); break;
case '/': EnterOperator(Operator.Divide); break;
case '=':
int newValue = Convert.ToInt32(DisplayValue);
var node = Insert(_head, newValue, Operator.None);
var calculationValue = Calculate(node);
DisplayValue = calculationValue.ToString();
_head = null;
_isEditing = false;
break;
default:
break;
}
}
private void EnterControl(Control control)
{
Debug.WriteLine("Control " + control.ToString());
switch (control)
{
case Control.Clear:
DisplayValue = "0";
_head = null;
IsEditing = false;
break;
case Control.ClearE:
DisplayValue = "0";
IsEditing = false;
break;
case Control.Back:
var displayValue = DisplayValue;
if (displayValue.Length > 1)
{
DisplayValue = displayValue.Substring(0, displayValue.Length - 1);
}
else
{
DisplayValue = "0";
IsEditing = false;
}
break;
case Control.Calculate:
int newValue = Convert.ToInt32(DisplayValue);
var node = InsertFinal(_head, newValue);
var calculationValue = Calculate(node);
DisplayValue = calculationValue.ToString();
_head = null;
EquationDisplay += string.Format("{0}=", newValue);
IsEditing = false;
break;
default:
break;
}
}
private CalculationNode InsertFinal(CalculationNode node, int value)
{
if (node == null)
{
return(new CalculationNode(value));
}
else if (node.Value is NumericValue)
{
return(new CalculationNode(value));
}
else if (node.Right == null)
{
node.Right = new CalculationNode(value);
}
else
{
InsertFinal(node.Right, value);
}
return(node);
}
private void EnterOperator(Operator @operator)
{
switch (@operator)
{
case Operator.Add:
case Operator.Multiply:
case Operator.Subtract:
case Operator.Divide:
Debug.WriteLine("Operator " + @operator.ToString());
int newValue = Convert.ToInt32(DisplayValue);
_head = Insert(_head, newValue, @operator);
AppendOperatorToEquation(@operator, newValue);
IsEditing = false;
break;
case Operator.Reciprocal:
throw new NotImplementedException("Reciprocal");
break;
case Operator.Percent:
throw new NotImplementedException("Percent");
break;
case Operator.Invert:
throw new NotImplementedException("Invert");
break;
case Operator.Negate:
throw new NotImplementedException("Negate");
break;
case Operator.Radical:
throw new NotImplementedException("Radical");
break;
default:
break;
}
}
private int Calculate(CalculationNode node)
{
if (node == null)
{
return(0);
}
var numeric = node.Value as NumericValue;
if (numeric != null)
{
return(numeric.Value);
}
if (node.Right == null)
{
return(Calculate(node.Left));
}
var @operator = ((OperatorValue)node.Value).Value;
var left = Calculate(node.Left);
var right = Calculate(node.Right);
switch (@operator)
{
case Operator.Add: return(left + right);
case Operator.Subtract: return(left - right);
case Operator.Multiply: return(left * right);
case Operator.Divide: return(Convert.ToInt32(left / right));
case Operator.None:
default: return(0);
}
}
void ContextCallback(object obj)
{
string clb = obj.ToString();
if (clb.Equals("noiseNode"))
{
NoiseNode noiseNode = new NoiseNode();
noiseNode.windowRect = new Rect(mousePos, new Vector2(200, 150));
//noiseNode.myComputeTextureCreator = computeTextureCreator;
nodes.Add(noiseNode);
noiseNode.name = "zzz" + noiseNode.name + saver.assetAmount.ToString();
noiseNode.index = nodes.Count - 1;
saver.assetAmount += 1;
saver.nodes.Add(noiseNode);
AssetDatabase.AddObjectToAsset(noiseNode, pathName);
AssetDatabase.SaveAssets();
//AssetDatabase.ImportAsset(pathName);
}
else if (clb.Equals("calculationNode"))
{
CalculationNode noiseNode = new CalculationNode();
noiseNode.windowRect = new Rect(mousePos, new Vector2(200, 150));
nodes.Add(noiseNode);
noiseNode.name = "zzz" + noiseNode.name + saver.assetAmount.ToString();
saver.assetAmount += 1;
saver.nodes.Add(noiseNode);
AssetDatabase.AddObjectToAsset(noiseNode, pathName);
AssetDatabase.SaveAssets();
}
else if (clb.Equals("outputNode"))
{
OutputNode noiseNode = new OutputNode();
noiseNode.windowRect = new Rect(mousePos, new Vector2(200, 200));
nodes.Add(noiseNode);
noiseNode.name = "zzz" + noiseNode.name + saver.assetAmount.ToString();
saver.assetAmount += 1;
saver.nodes.Add(noiseNode);
AssetDatabase.AddObjectToAsset(noiseNode, pathName);
AssetDatabase.SaveAssets();
}
else if (clb.Equals("waveNode"))
{
WaveNode noiseNode = new WaveNode();
noiseNode.windowRect = new Rect(mousePos, new Vector2(200, 200));
nodes.Add(noiseNode);
noiseNode.name = "zzz" + noiseNode.name + saver.assetAmount.ToString();
saver.assetAmount += 1;
saver.nodes.Add(noiseNode);
AssetDatabase.AddObjectToAsset(noiseNode, pathName);
AssetDatabase.SaveAssets();
}
else if (clb.Equals("makeTransition"))
{
bool clickedOnWindow = false;
BaseNode tempSelectedNode = null;
foreach (BaseNode node in nodes)
{
if (node.windowRect.Contains(mousePos))
{
tempSelectedNode = node;
clickedOnWindow = true;
break;
}
}
if (clickedOnWindow)
{
selectedNode = tempSelectedNode;
makeTransitionMode = true;
}
AssetDatabase.SaveAssets();
}
else if (clb.Equals("callMethod"))
{
foreach (BaseNode node in nodes)
{
if (node.windowRect.Contains(mousePos))
{
((NoiseNode)(node)).TheMethod(0);
break;
}
}
}
else if (clb.Equals("deleteNode"))
{
bool clickedOnWindow = false;
BaseNode tempSelectedNode = null;
int index = 0;
foreach (BaseNode node in nodes)
{
if (node.windowRect.Contains(mousePos))
{
index = nodes.IndexOf(node);
tempSelectedNode = node;
clickedOnWindow = true;
break;
}
}
if (clickedOnWindow)
{
//nodes = nodes.Where(x => x.index != index).ToList();
//nodes.Remove(tempSelectedNode);
nodes.Remove(tempSelectedNode);
saver.nodes.Remove(tempSelectedNode);
//nodes.RemoveAt(index);
foreach (BaseNode node in nodes)
{
node.NodeDeleted(tempSelectedNode);
//node.NodeDeleted(index);
}
DestroyImmediate(tempSelectedNode, true);
AssetDatabase.SaveAssets();
//AssetDatabase.ImportAsset(pathName);
}
}
}
private CalculationNode Insert(CalculationNode node, int value, Operator @operator)
{
if (node == null)
{
return(new CalculationNode(@operator)
{
Left = new CalculationNode(value)
});
}
else if (node.Value is NumericValue)
{
return(new CalculationNode(@operator)
{
Left = node
});
}
else
{
var headOperator = ((OperatorValue)node.Value).Value;
switch (headOperator)
{
case Operator.Divide:
case Operator.Multiply:
node.Right = new CalculationNode(value);
return(new CalculationNode(@operator)
{
Left = node
});
case Operator.Add:
case Operator.Subtract:
if (node.Right == null)
{
switch (@operator)
{
case Operator.Add:
case Operator.Subtract:
node.Right = new CalculationNode(value);
return(new CalculationNode(@operator)
{
Left = node
});
case Operator.Divide:
case Operator.Multiply:
node.Right = new CalculationNode(@operator)
{
Left = new CalculationNode(value)
};
return(node);
default:
return(node);
}
}
else
{
node.Right = Insert(node.Right, value, @operator);
return(node);
}
default:
return(node);
}
}
}
void CreateInstructionBuffer()
{
instructionBuffer = new List <float>();
for (int i = 0; i < PriorityQueue.Count; i++)
{
BaseInputNode node = PriorityQueue[i];
if (node.priority == 0)
{
instructionBuffer.Add(-1f);
instructionBuffer.Add(i);
}
else if (node.HasInputs())
{
if (node.GetType() == typeof(NoiseNode))
{
NoiseNode noiseNode = (NoiseNode)node;
instructionBuffer.Add(-3);
instructionBuffer.Add(i);
for (int j = 0; j < noiseNode.inputNodes.Count; j++)
{
foreach (BaseInputNode node1 in noiseNode.inputNodes[j].nodes)
{
instructionBuffer.Add(PriorityQueue.IndexOf(node1) + j / 100);
}
}
instructionBuffer.Add(i);
}
if (node.GetType() == typeof(CalculationNode))
{
CalculationNode calcNode = (CalculationNode)node;
switch (calcNode.calcType)
{
case CalcType.Adition:
instructionBuffer.Add(-2.1f);
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[0]));
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[1]));
break;
case CalcType.Subtraction:
instructionBuffer.Add(-2.2f);
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[0]));
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[1]));
break;
case CalcType.Division:
instructionBuffer.Add(-2.3f);
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[0]));
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[1]));
break;
case CalcType.Multiplication:
instructionBuffer.Add(-2.4f);
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[0]));
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[1]));
break;
case CalcType.SingleNumber:
instructionBuffer.Add(-2.5f);
break;
case CalcType.Clamp:
instructionBuffer.Add(-2.6f);
if (calcNode.inputNodes[0] != null)
{
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[0]));
}
else if (calcNode.inputNodes[1] != null)
{
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[1]));
}
instructionBuffer.Add(calcNode.clampValues.x);
instructionBuffer.Add(calcNode.clampValues.y);
break;
case CalcType.ReScale:
instructionBuffer.Add(-2.7f);
if (calcNode.inputNodes[0] != null)
{
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[0]));
}
else if (calcNode.inputNodes[1] != null)
{
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[1]));
}
instructionBuffer.Add(calcNode.numberScale.x);
instructionBuffer.Add(calcNode.numberScale.y);
break;
}
}
}
}
}
