public MethodInvokeExpressionNode() : base("out", "Out (ref exp)") { name = "Method Invoke"; m_Method = CreateInputSlot <EmptySlot <CodeMethodReferenceExpression> >("method", "Method (ref exp)"); m_Parameters = CreateInputSlot <EmptySlot <CodeExpression> >("params", "Params (exp)"); m_Parameters.allowMultipleConnections = true; }
bool CheckForNoMoreMoves() { int midSlotIndex = 0, sub = 0; for (int index = 0; index < Slots.Length; index++) { _slotIter = Slots[index]; //Debug.Log(_slotIter.Index + " " + _slotIter.HasPeg); if (_slotIter.HasPeg) { for (sub = 0; sub < Slots.Length; sub++) { if (index != sub) { midSlotIndex = (index + sub) / 2; //Debug.Log(_slotIter.Index + " " + Slots[midSlotIndex].Index + " " + Slots[sub].Index); if (CanMove(_slotIter, Slots[midSlotIndex], Slots[sub])) { return(false); } } } } } return(true); }
void SlotClicked(EmptySlot slot) { int midSlotIndex = (_currentPeg.Slot.Index + slot.Index) / 2; EmptySlot midSlot = Slots[midSlotIndex]; //Debug.Log("start index: " + _currentPeg.Slot.Index + " target index: " + slot.Index + " middle slot: " + midSlotIndex); if (CanMove(_currentPeg.Slot, midSlot, slot)) { _currentPeg.Slot.ClearPeg(); slot.SetPeg(_currentPeg); _currentPeg.SetInactive(); midSlot.ClearPeg(); _pegCount--; if (_pegCount == PEGS_LEFT_TO_WIN) { EndGame(true); } else if (CheckForNoMoreMoves()) { EndGame(false); } } }
public ClampFLoat() { m_Input0 = CreateInputSlot <EmptySlot <float> >(0, "val"); m_Input1 = CreateInputSlot <ValueSlot <float> >(1, "min").SetShowControl().SetValue(0); m_Input2 = CreateInputSlot <ValueSlot <float> >(2, "max").SetShowControl().SetValue(1); CreateOutputSlot <GetterSlot <float> >(3, "Out").SetGetter(Execute); }
public ExecutionFilterNode() { m_Event = CreateInputSlot <EmptySlot <Action <UIEventData> > >("Event"); m_Event.SetAllowMultipleConnections(true); m_Filter = CreateInputSlot <ValueSlot <bool> >("Filter").SetShowControl(); CreateOutputSlot <DefaultValueSlot <Action <UIEventData> > >("UI Event").SetDefaultValue(Execute); }
public NamespaceNode() { name = "Namespace Declaration"; m_Types = CreateInputSlot <EmptySlot <CodeTypeDeclaration> >("types", "Types (dec)"); m_Types.allowMultipleConnections = true; m_Imports = CreateInputSlot <EmptySlot <CodeNamespaceImport> >("imports", "Imports"); m_Imports.allowMultipleConnections = true; }
public UIMasterNode() { name = "UI Master Node"; m_Input = CreateInputSlot <EmptySlot <Action <UIEventData> > >("UI Event"); m_Input.SetAllowMultipleConnections(true); m_Rect = CreateInputSlot <ValueSlot <Rect> >("Rect").SetShowControl(); m_Matrix = CreateInputSlot <DefaultValueSlot <Matrix4x4> >("Matrix").SetDefaultValue(Matrix4x4.identity); }
public TypeNode() { name = "Type Declaration"; m_TypeBuilder = CreateOutputSlot <GetterSlot <CodeTypeDeclaration> >("type", "Type (dec)").SetGetter(Build); m_Members = CreateInputSlot <EmptySlot <CodeTypeMember> >("members", "Members (mem)"); m_BaseTypes = CreateInputSlot <EmptySlot <CodeTypeReference> >("baseTypes", "Base Types (ref)"); m_Comments = CreateInputSlot <EmptySlot <CodeCommentStatement> >("comments", "Comments (stm)"); m_Members.allowMultipleConnections = true; }
public MethodNode() { name = "Method Member"; m_ReturnType = CreateInputSlot <CodeTypeReferenceSlot>("returnType", "ReturnType (ref)"); m_ReturnType.SetValue("System.Void"); m_Parameters = CreateInputSlot <EmptySlot <CodeParameterDeclarationExpression> >("parameters", "Parameters (dec exp)"); m_Parameters.allowMultipleConnections = true; m_Statements = CreateInputSlot <EmptySlot <CodeStatement> >("statements", "Statements (stm)"); m_Statements.allowMultipleConnections = true; }
public UIElementNode() { m_Event = CreateInputSlot <EmptySlot <Action <UIEventData> > >("Event"); m_Event.SetAllowMultipleConnections(true); m_Position = CreateInputSlot <ValueSlot <Vector2> >("pos", "Position").SetShowControl(); m_Size = CreateInputSlot <ValueSlot <Vector2> >("size", "Size").SetValue(new Vector2(100, 100)).SetShowControl(); m_OffsetMin = CreateInputSlot <ValueSlot <Vector2> >("minOffset", "Offset Min").SetShowControl(); m_OffsetMax = CreateInputSlot <ValueSlot <Vector2> >("maxOffset", "Offset Max").SetShowControl(); m_AnchorMin = CreateInputSlot <ValueSlot <Vector2> >("minAnchor", "Anchor Min %").SetValue(new Vector2(0.5f, 0.5f)).SetShowControl(); m_AnchorMax = CreateInputSlot <ValueSlot <Vector2> >("maxAnchor", "Anchor Max %").SetValue(new Vector2(0.5f, 0.5f)).SetShowControl(); }
void Awake() { selectedSlot = SlotLength; PassiveSkillList = new List <Skill>(); DebuffList = new List <Skill>(); SlotList = new EmptySlot[SlotLength]; for (int i = 0; i < SlotLength; i++) { SlotList[i] = new EmptySlot(); } }
public TextNode() { m_Text = CreateInputSlot <ValueSlot <string> >("Text").SetShowControl(); m_FontSize = CreateInputSlot <ValueSlot <int> >("Size").SetValue(DefaultFontSize).SetShowControl(); m_Pivot = CreateInputSlot <ValueSlot <Vector2> >("Pivot").SetShowControl(); m_Color = CreateInputSlot <ValueSlot <Color> >("Color").SetValue(Color.white).SetShowControl(); m_Font = CreateInputSlot <DefaultValueSlot <Font> >("Font"); m_Matrix = CreateInputSlot <DefaultValueSlot <Matrix4x4> >("Matrix").SetDefaultValue(Matrix4x4.identity); m_Material = CreateInputSlot <EmptySlot <Material> >("Material"); CreateOutputSlot <ValueSlot <Action <UIEventData> > >("UI Event").SetValue(Execute); CreateOutputSlot <GetterSlot <Rect> >("Extents").SetGetter(() => m_TextGenerator.rectExtents); }
public void StartGame() { int index = 0; EmptySlot slot = null; for (index = 0; index < Slots.Length; index++) { slot = Slots[index]; slot.clicked += SlotClicked; slot.Index = index; } Peg peg = null; _pegCount = 0; for (index = Slots.Length - 1; index > 0; index--) { peg = Pegs[_pegCount]; peg.clicked += PegClicked; Slots[index].SetPeg(peg); _pegCount++; } }
public void Restart() { int index = 0; EmptySlot slot = null; for (index = 0; index < Slots.Length; index++) { slot = Slots[index]; slot.Index = index; slot.ClearPeg(); } Peg peg = null; _pegCount = 0; for (index = Slots.Length - 1; index > 0; index--) { peg = Pegs[_pegCount]; peg.SetInactive(); Slots[index].SetPeg(peg); _pegCount++; } }
public MethodReferenceExpressionNode() : base("method", "Method (ref exp)") { name = "Method Reference"; m_Target = CreateInputSlot <EmptySlot <CodeExpression> >("target", "Target (exp)"); m_TypeArguments = CreateInputSlot <EmptySlot <CodeTypeReference> >("typeArguments", "Type Arguments (ref)"); }
protected MultiplyNode() { m_Input0 = CreateInputSlot <EmptySlot <T> >("0"); m_Input1 = CreateInputSlot <EmptySlot <T> >("1"); CreateOutputSlot <GetterSlot <T> >("Out").SetGetter(MultiplyInternal); }
bool CanMove(EmptySlot startSlot, EmptySlot midSlot, EmptySlot target) { return(midSlot.HasPeg && //check if the middle index has a peg ((startSlot.RowIndex == target.RowIndex && Mathf.Abs(startSlot.IndexInRow - target.IndexInRow) == SEPARATION) || //check if they are in the same row and 2 separate (Mathf.Abs(startSlot.RowIndex - target.RowIndex) == SEPARATION && startSlot.IndexInRow % 2 == target.IndexInRow % 2))); //check if they are in separate rows which are 2 apart && are the same parity (even or odd) }
public MethodReturnStatementNode() : base("out", "Out (stm)") { name = "Method Return"; m_Expresion = CreateInputSlot <EmptySlot <CodeExpression> >("expression", "Exp (exp)"); }
public ObjectCreateExpressionNode() : base("out", "Object (exp)") { m_Type = CreateInputSlot <CodeTypeReferenceSlot>("type", "Type"); m_Parameters = CreateInputSlot <EmptySlot <CodeExpression> >("parameters", "Parameters"); m_Parameters.allowMultipleConnections = true; }
public void SetSlot(EmptySlot slot) { _slot = slot; }
public MultiplyFloat() { m_Input0 = CreateInputSlot <ValueSlot <float> >(0, "x").SetShowControl(); m_Input1 = CreateInputSlot <EmptySlot <float> >(1, "y"); CreateOutputSlot <GetterSlot <float> >(3, "Out").SetGetter(Execute); }
public FieldNode() { name = "Field Member"; m_VariableType = CreateInputSlot <CodeTypeReferenceSlot>("type", "Type (ref)"); m_InitExpresion = CreateInputSlot <EmptySlot <CodeExpression> >("init", "Init (exp)"); }
public ExpressionStatementNode() : base("out", "This (stm)") { name = "Expression Statement"; m_Expression = CreateInputSlot <EmptySlot <CodeExpression> >("expression", "Exp (exp)"); }
public To3DNode() { m_Input = CreateInputSlot <EmptySlot <Vector2> >("In"); CreateOutputSlot <GetterSlot <Vector3> >("Out").SetGetter(() => m_Input[this]); }
protected MethodNode(string x, string o) { m_Input = CreateInputSlot <EmptySlot <TInput> >(0, x); CreateOutputSlot <GetterSlot <TOutput> >(1, o).SetGetter(ExecuteInternal); }
// Do your threaded task. DON'T use the Unity API here protected override void ThreadFunction() { /* * I could of split each type of generation into their own methods, but I just used regions instead :/ */ //The C# Random instance Random rnd = new Random(seed); //Set the size of the whole city citySlots = new GeneratedSlot[citySize, citySize]; //Setting the list roads = new List <Road>(); //Setting all the tiles first so we don't get any errors later on EmptySlot emptySlot = new EmptySlot(); for (int x = 0; x < citySize; x++) { for (int y = 0; y < citySize; y++) { citySlots[x, y] = emptySlot; } } #region Motorway /* * * Motorway * */ //Generate the one motorway from top to bottom int motorwayStartX = 20 + rnd.Next(citySize - 40); //Picks a random number from 0 to city size //The motorway is always going to be the size of the city Vector3[] points = new Vector3[citySize]; //The first slot won't be connected to anything citySlots[motorwayStartX, 0] = new RoadSlot(RoadSlot.Type.M, 0); points[0] = new Vector3(motorwayStartX, 0, 0); //This for loop will go from top to bottom along the one x axis to create the motorway for (int i = 1; i < citySize; i++) { citySlots[motorwayStartX, i] = new RoadSlot(RoadSlot.Type.M, 0); points[i] = new Vector3(motorwayStartX, 0, i); } Road motorway = new Road(points, RoadType.M); roads.Add(motorway); #endregion #region A-Road /* * * A-Road * * Each side of the motorway there will be 3 different A roads unless * the motorway is less that the minium size for small houses */ //Left side Vector3[] a1Points = new Vector3[motorwayStartX]; Vector3[] a2Points = new Vector3[motorwayStartX]; Vector3[] a3Points = new Vector3[motorwayStartX]; //Right side Vector3[] a4Points = new Vector3[citySize - motorwayStartX]; Vector3[] a5Points = new Vector3[citySize - motorwayStartX]; Vector3[] a6Points = new Vector3[citySize - motorwayStartX]; for (int i = 0; i < motorwayStartX; i++) { CheckSlotForRoad(motorwayStartX - i, 0, 0, 0, RoadSlot.Type.A, RoadSlot.Type.A, 90); a1Points[i] = new Vector3(motorwayStartX - i, 0, 0); CheckSlotForRoad(motorwayStartX - i, citySize / 2, 0, 0, RoadSlot.Type.A, RoadSlot.Type.A, 90); a2Points[i] = new Vector3(motorwayStartX - i, 0, citySize / 2); CheckSlotForRoad(motorwayStartX - i, citySize - 1, 0, 0, RoadSlot.Type.A, RoadSlot.Type.A, 90); a3Points[i] = new Vector3(motorwayStartX - i, 0, citySize - 1); } for (int i = 0; i < citySize - motorwayStartX; i++) { CheckSlotForRoad(motorwayStartX + i, 0, 0, 0, RoadSlot.Type.A, RoadSlot.Type.A, 90); a4Points[i] = new Vector3(motorwayStartX + i, 0, 0); CheckSlotForRoad(motorwayStartX + i, citySize / 2, 0, 0, RoadSlot.Type.A, RoadSlot.Type.A, 90); a5Points[i] = new Vector3(motorwayStartX + i, 0, citySize / 2); CheckSlotForRoad(motorwayStartX + i, citySize - 1, 0, 0, RoadSlot.Type.A, RoadSlot.Type.A, 90); a6Points[i] = new Vector3(motorwayStartX + i, 0, citySize - 1); } Road a1 = new Road(a1Points, RoadType.A); Road a2 = new Road(a2Points, RoadType.A); Road a3 = new Road(a3Points, RoadType.A); Road a4 = new Road(a4Points, RoadType.A); Road a5 = new Road(a5Points, RoadType.A); Road a6 = new Road(a6Points, RoadType.A); roads.Add(a1); roads.Add(a2); roads.Add(a3); roads.Add(a4); roads.Add(a5); roads.Add(a6); #endregion #region S-Road Housing /* * * Side Road Housing * * */ //These two roads are the roads we are going to be finding the random points off of Road leftStraightRoad = a1; Road rightStraightRoad = a4; int amountOfSideRoads = rnd.Next(0, 5); //This number will be used to how many random points we find for (int i = 0; i < (citySize / 2) - 2; i += 2) { Vector3[] leftRoadPoints = new Vector3[motorwayStartX - 2]; //There is some overflow here, not sure why Vector3[] rightRoadPoints = new Vector3[citySize - motorwayStartX - 2]; Vector2[] leftRandomPoints = new Vector2[amountOfSideRoads]; Vector2[] rightRandomPoints = new Vector2[amountOfSideRoads]; //First find the random points that we want to use for (int j = 0; j < amountOfSideRoads; j++) { //This will give a random point of the points list to pick from int leftPoint = rnd.Next(leftStraightRoad.points.Length - 1); int rightPoint = rnd.Next(rightStraightRoad.points.Length - 1); Vector2 leftVector2 = leftStraightRoad.points[leftPoint + 1]; Vector2 rightVector2 = rightStraightRoad.points[rightPoint + 1]; leftRandomPoints[j] = leftVector2; rightRandomPoints[j] = rightVector2; } //Loop for the whole length that the road needs to be for (int j = 0; j < citySize - motorwayStartX - 2; j++) { int x = motorwayStartX + j + 2; int y = i + 2; RoadSlot rightSlot = new RoadSlot(RoadSlot.Type.S, 90); rightRoadPoints[j] = new Vector3(x, 0, y); for (int k = 0; k < rightRandomPoints.Length; k++) { if (rightRandomPoints[k].x == x) { rightSlot.AddConnection(x, y - 1, RoadSlot.Type.S); //There should be the road we had done before in this slot, so we are just adding a connection CheckSlotForRoad(x, i, x, i + 1, RoadSlot.Type.S, RoadSlot.Type.S, 90); RoadSlot middleSlot = new RoadSlot(RoadSlot.Type.S, 0); citySlots[x, y - 1] = middleSlot; Vector3[] smallRoadPoints = new Vector3[3]; smallRoadPoints[0] = new Vector3(x, 0, y); smallRoadPoints[1] = new Vector3(x, 0, y - 1); smallRoadPoints[2] = new Vector3(x, 0, i); roads.Add(new Road(smallRoadPoints, RoadType.S)); //Rotating the bottom S road if (citySlots[x, i] is RoadSlot) { if (((RoadSlot)citySlots[x, i]).type == RoadSlot.Type.S) { ((RoadSlot)citySlots[x, i]).primaryDirection += 180; } } break; } else { //If there is no road joining the two straight lines, this should be a building citySlots[x, y - 1] = new BuildingSlot(); } } citySlots[x, y] = rightSlot; } for (int j = 0; j < motorwayStartX - 2; j++) { int x = motorwayStartX - j - 2; int y = i + 2; RoadSlot leftSlot = new RoadSlot(RoadSlot.Type.S, 90); leftRoadPoints[j] = new Vector3(x, 0, y); for (int k = 0; k < leftRandomPoints.Length; k++) { if (leftRandomPoints[k].x == x) { leftSlot.AddConnection(x, y - 1, RoadSlot.Type.S); //There should be the road we had done before in this slot, so we are just adding a connection CheckSlotForRoad(x, i, x, i + 1, RoadSlot.Type.S, RoadSlot.Type.S, 90); RoadSlot middleSlot = new RoadSlot(RoadSlot.Type.S, 0); citySlots[x, y - 1] = middleSlot; Vector3[] smallRoadPoints = new Vector3[3]; smallRoadPoints[0] = new Vector3(x, 0, y); smallRoadPoints[1] = new Vector3(x, 0, y - 1); smallRoadPoints[2] = new Vector3(x, 0, i); roads.Add(new Road(smallRoadPoints, RoadType.S)); //Rotating the bottom S road if (citySlots[x, i] is RoadSlot) { if (((RoadSlot)citySlots[x, i]).type == RoadSlot.Type.S) { ((RoadSlot)citySlots[x, i]).primaryDirection += 180; } } break; } else { //If there is no road joining the two straight lines, this should be a building citySlots[x, y - 1] = new BuildingSlot(); } } citySlots[x, y] = leftSlot; } Road left = new Road(leftRoadPoints, RoadType.S); Road right = new Road(rightRoadPoints, RoadType.S); leftStraightRoad = left; rightStraightRoad = right; roads.Add(left); roads.Add(right); } //Connecting the the middle A roads Vector2[] leftLastRandomPoints = new Vector2[amountOfSideRoads]; Vector2[] rightLastRandomPoints = new Vector2[amountOfSideRoads]; for (int i = 0; i < amountOfSideRoads; i++) { Vector3[] leftPoints = new Vector3[3]; Vector3[] rightPoints = new Vector3[3]; //This will give a random point of the points list to pick from int leftPoint = rnd.Next(leftStraightRoad.points.Length); int rightPoint = rnd.Next(rightStraightRoad.points.Length); leftPoints[0] = new Vector3(leftStraightRoad.points[leftPoint].x, 0, (citySize / 2) - 2); leftPoints[1] = new Vector3(leftStraightRoad.points[leftPoint].x, 0, (citySize / 2)); leftPoints[2] = new Vector3(leftStraightRoad.points[leftPoint].x, 0, (citySize / 2)); rightPoints[0] = new Vector3(rightStraightRoad.points[rightPoint].x, 0, (citySize / 2) - 2); rightPoints[1] = new Vector3(rightStraightRoad.points[rightPoint].x, 0, (citySize / 2) - 1); rightPoints[2] = new Vector3(rightStraightRoad.points[rightPoint].x, 0, (citySize / 2)); //These float should already be a whole number anyways int rightX = Mathf.RoundToInt(rightPoints[0].x); int leftX = Mathf.RoundToInt(leftPoints[0].x); int y = Mathf.RoundToInt(leftStraightRoad.points[0].z); //Adding it to the slot array CheckSlotForRoad(rightX, y, rightX, y + 1, RoadSlot.Type.S, RoadSlot.Type.S, 180); CheckSlotForRoad(rightX, y + 1, 0, 0, RoadSlot.Type.S, RoadSlot.Type.S, 0); CheckSlotForRoad(rightX, y + 2, rightX, y + 1, RoadSlot.Type.S, RoadSlot.Type.S, 180); CheckSlotForRoad(leftX, y, leftX, y + 1, RoadSlot.Type.S, RoadSlot.Type.S, 180); CheckSlotForRoad(leftX, y + 1, 0, 0, RoadSlot.Type.S, RoadSlot.Type.S, 0); CheckSlotForRoad(leftX, y + 2, leftX, y + 1, RoadSlot.Type.S, RoadSlot.Type.S, 180); //Having to do some manual correction as CheckSlotsForRoad has a flaw ((RoadSlot)citySlots[leftX, y]).primaryDirection = 270; ((RoadSlot)citySlots[leftX, y + 2]).primaryDirection = 270; ((RoadSlot)citySlots[rightX, y]).primaryDirection = 270; ((RoadSlot)citySlots[rightX, y + 2]).primaryDirection = 270; Road leftSmallRoad = new Road(leftPoints, RoadType.S); Road rightSmallRoad = new Road(rightPoints, RoadType.S); roads.Add(leftSmallRoad); roads.Add(rightSmallRoad); } #endregion #region S-Road Factories /* * * S-Road Factories * * The way the roads are going to generate will be based of a fixed size * So for every 10 units, we place a road then inside of that 10 units we would spawn the prefab for the factory * if there is less that 10 units left we just stop * * If there is less than 10 units on the whole side we just leave that side. */ //First we want to work out how many times we can move along on one side // float factorySize = 4; int leftFactoryRoads = Mathf.FloorToInt(motorwayStartX / factorySize); int rightFactoryRoads = Mathf.FloorToInt((citySize - motorwayStartX) / factorySize); citySlots[motorwayStartX + 1, (citySize / 2) + 1] = new FactorySlot(true, true); citySlots[motorwayStartX - 1, (citySize / 2) + 1] = new FactorySlot(true, false); //Left side for (int i = 1; i <= leftFactoryRoads; i++) { int roadX = Mathf.RoundToInt(motorwayStartX - (factorySize * i)); int distance = citySize / 2 - 2; //For the distance between the middle road and the top road, we create a straight line on x Vector3[] currentRoadPoints = new Vector3[distance]; //This should be half the size CheckSlotForRoad(roadX, citySize / 2, roadX, citySize / 2, RoadSlot.Type.S, RoadSlot.Type.S, 0); for (int j = 0; j < distance; j++) { int y = j + citySize / 2 + 1; currentRoadPoints[j] = new Vector3(roadX, 0, y); citySlots[roadX, y] = new RoadSlot(RoadSlot.Type.S, 0); //Every 4 if (j % 2 == 0 && roadX - 1 > 0) { //Adding the factory spawn citySlots[roadX - 1, y] = new FactorySlot(true, false); } } Road currentRoad = new Road(currentRoadPoints, RoadType.S); roads.Add(currentRoad); } //Right Side for (int i = 1; i <= rightFactoryRoads; i++) { int roadX = Mathf.RoundToInt(motorwayStartX + (factorySize * i)); int distance = citySize / 2 - 2; //For the distance between the middle road and the top road, we create a straight line on x Vector3[] currentRoadPoints = new Vector3[distance]; //This should be half the size CheckSlotForRoad(roadX, citySize / 2, roadX, citySize / 2, RoadSlot.Type.S, RoadSlot.Type.S, 0); for (int j = 0; j < distance; j++) { int y = j + citySize / 2 + 1; currentRoadPoints[j] = new Vector3(roadX, 0, y); citySlots[roadX, y] = new RoadSlot(RoadSlot.Type.S, 0); //Every 4 if (j % 2 == 0 && roadX + 1 < 100) { //Adding the factory spawn citySlots[roadX + 1, y] = new FactorySlot(true, true); } } Road currentRoad = new Road(currentRoadPoints, RoadType.S); roads.Add(currentRoad); } //This does a for loop coving anything which isn't a road in the factory area for (int x = 0; x < citySize; x++) { for (int y = 0; y < (citySize / 2) - 2; y++) { if (citySlots[x, y + ((citySize / 2) + 1)] is EmptySlot) { citySlots[x, y + ((citySize / 2) + 1)] = new FactorySlot(); } } } #endregion }
public CastExpressionNode() : base("out", "Cast (exp)") { m_Type = CreateInputSlot <CodeTypeReferenceSlot>("type", "Type (ref)"); m_Expression = CreateInputSlot <EmptySlot <CodeExpression> >("exp", "Cast (exp)"); }
public EmptyWrapper(EmptySlot emptySlot) : base() { this._emptySlot = emptySlot; }
public FieldReferenceExpressionNode() : base("out", "Out (ref exp)") { name = "Field Reference"; m_Target = CreateInputSlot <EmptySlot <CodeExpression> >("target", "Target (exp)"); }