public void RemoveWire(string id)
{
Guid guid = Guid.Parse(id);
IntegratedCircuit ic = breadBoard.GetIntegratedCircuit(guid);
breadBoard.UnlinkNodes(ic.GetPinNode(0), ic.GetPinNodeIndex(0), ic.GetPinNode(1), ic.GetPinNodeIndex(1));
breadBoard.components.Remove(guid);
}
public void RemoveIntegratedCircuit(string id)
{
Guid guid = Guid.Parse(id);
IntegratedCircuit ic = breadBoard.GetIntegratedCircuit(guid);
ic.Update(true);
for (int i = 0; i < ic.Pins; i++)
{
breadBoard.RemoveNodeConnection(ic.GetPinNode(i), ic.GetPinNodeIndex(i));
}
breadBoard.components.Remove(guid);
}
public void GivenOneIC_WhenRemoveOnlyIC_ThenStoreShouldBeEmpty()
{
var ic = new IntegratedCircuit {
Code = "1", Description = "Test1"
};
Session.Save(ic);
Session.Flush();
var result = Post("/api/deleteic/" + ic.Id, new { });
result.StatusCode.ShouldBe(HttpStatusCode.OK);
Session.Query <IntegratedCircuit>().ShouldBeEmpty();
}
// todo: find a way to wire this into the UI. this will make a comprehensive demo.
public IHttpActionResult Post(PostModel model)
{
if (!_devAccessChecker.UserHasDevAccess())
return NotFound();
if (string.IsNullOrWhiteSpace(model.code) || string.IsNullOrWhiteSpace(model.description))
return BadRequest("IC was not added: please send all fields.");
var newIc = new IntegratedCircuit { Code = model.code, Description = model.description };
_session.Save(newIc);
var location = Url.Link("DefaultApi", new { controller = "ics", id = newIc.Id });
return Created(location, newIc);
}
public GameObject GetIntegratedCircuitObj(IntegratedCircuit circuit)
{
GameObject obj = GetIntegratedCircuitObj(circuit.ModelName);
circuit.AssignObjRef(obj);
obj.name = circuit.SetBreadBoard(breadBoard).ToString();
Text text = obj.GetComponentInChildren <Text>();
if (text != null && circuit.OverwriteObjText)
{
text.text = circuit.GetType().Name.Split('_')[0];
}
return(obj);
}
private Vector2Int NodeValues(string nodeId)
{
Vector2Int result = new Vector2Int(0, 0);
int nodeListIndex = 0;
List <string> nodeList = new List <string>();
nodeList.Add(nodeId);
while (nodeListIndex < nodeList.Count)
{
Node node = nodes[nodeList[nodeListIndex]];
nodeListIndex++;
foreach (Connection connection in node.connections.Values)
{
if (!connection.ID.Equals(""))
{
if (connection.IsNode)
{
if (!nodeList.Contains(connection.ID))
{
nodeList.Add(connection.ID);
}
}
else
{
IntegratedCircuit ic = components[Guid.Parse(connection.ID)];
int state = ic.GetPinState(connection.Index);
if (state == -1)
{
result.y--;
}
else if (state == 1)
{
result.x++;
}
}
}
}
}
return(result);
}
// todo: find a way to wire this into the UI. this will make a comprehensive demo.
public IHttpActionResult Post(PostModel model)
{
if (!_devAccessChecker.UserHasDevAccess())
{
return(NotFound());
}
if (string.IsNullOrWhiteSpace(model.code) || string.IsNullOrWhiteSpace(model.description))
{
return(BadRequest("IC was not added: please send all fields."));
}
var newIc = new IntegratedCircuit {
Code = model.code, Description = model.description
};
_session.Save(newIc);
var location = Url.Link("DefaultApi", new { controller = "ics", id = newIc.Id });
return(Created(location, newIc));
}
public bool GetIntegratedCircuit(out RaycastHit hit, out IntegratedCircuit ic)
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
ic = null;
int layer_mask = LayerMask.GetMask("Component");
if (Physics.Raycast(ray, out hit, 500, layer_mask) && !EventSystem.current.IsPointerOverGameObject())
{
if (Guid.TryParse(hit.transform.parent.gameObject.name, out Guid guid))
{
ic = breadBoard.components[guid];
return(true);
}
else
{
return(false);
}
}
return(false);
}
public bool NodeHasICType(string nodeId, ICType iCType)
{
if (nodes.ContainsKey(nodeId))
{
Node node = nodes[nodeId];
foreach (Connection connection in node.connections.Values)
{
if (!connection.IsNode)
{
Guid id = Guid.Parse(connection.ID);
if (!connection.IsNode && components.ContainsKey(id))
{
IntegratedCircuit c = components[id];
if (c.IcType == iCType)
{
return(true);
}
}
}
}
}
return(false);
}
public GameObject PlaceIntegratedCircuit(IntegratedCircuit ic, string nodeIdA, int indexA, string nodeIdB, int indexB, bool skipUpdate)
{
// Debug.Log("Placing: " + IcName);
GameObject obj = Instantiate(GetIntegratedCircuitObj(ic), new Vector3(0, 0, 0), Quaternion.identity) as GameObject;
obj.transform.parent = parent;
ic.AssignObjRef(obj);
obj.name = ic.SetBreadBoard(breadBoard).ToString();
bool rotated = Helper.CircuitHelper.IsNodeRotated(nodeIdA);
switch (ic.IcType)
{
case ICType.solo:
breadBoard.SetNodeConnection(false, nodeIdA, indexA, 0, ic.GetId().ToString());
ic.SetPinIndex(0, indexA);
ic.SetPinNode(0, nodeIdA);
break;
case ICType.dual:
breadBoard.SetNodeConnection(false, nodeIdA, indexA, 0, ic.GetId().ToString());
ic.SetPinIndex(0, indexA);
ic.SetPinNode(0, nodeIdA);
breadBoard.SetNodeConnection(false, nodeIdB, indexB, 1, ic.GetId().ToString());
ic.SetPinIndex(1, indexB);
ic.SetPinNode(1, nodeIdB);
break;
case ICType.wire:
ic.SetPinNode(0, nodeIdA);
ic.SetPinIndex(0, indexA);
ic.SetPinNode(1, nodeIdB);
ic.SetPinIndex(1, indexB);
break;
case ICType.ic6:
case ICType.ic4:
string[] id = nodeIdA.Split('x');
int a = int.Parse(id[0]);
int b = int.Parse(id[1]);
int c = int.Parse(id[2]);
int d = int.Parse(id[3]);
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < ic.Pins / 2; j++)
{
string nodeId;
if (rotated)
{
nodeId = $"{a + i}x{b + (i * 7)}x{c}x{d + j}x{id[4]}";
}
else
{
nodeId = $"{a + i}x{b}x{c + (i * 7)}x{d + j}x{id[4]}";
}
int index = i == 0 ? 4 : 0;
if (ic.IcType == ICType.ic6)
{
index = i == 0 ? indexA : indexA - 1;
}
int pinIndex = i == 0 ? j : (ic.Pins - 1) - j;
if (ic.WriteToNodes)
{
breadBoard.SetNodeConnection(false, nodeId, index, pinIndex, ic.GetId().ToString());
}
ic.SetPinIndex(pinIndex, index);
ic.SetPinNode(pinIndex, nodeId);
}
}
break;
default:
return(null);
}
breadBoard.components.Add(ic.GetId(), ic);
if (!skipUpdate)
{
ic.Update();
}
return(obj);
}
public GameObject PlaceIntegratedCircuit(string IcName, string nodeIdA, int indexA, string nodeIdB, int indexB, bool skipUpdate)
{
IntegratedCircuit ic = GetIntegratedCircuit(IcName);
return(PlaceIntegratedCircuit(ic, nodeIdA, indexA, nodeIdB, indexB, skipUpdate));
}
public GameObject PlaceIntegratedCircuit(IntegratedCircuit ic, string nodeIdA, int indexA, bool skipUpdate)
{
return(PlaceIntegratedCircuit(ic, nodeIdA, indexA, "", 0, skipUpdate));
}
private void LoadComponents(ZipArchive archive)
{
int index = GetZipArchiveEntryIndex("components.json", archive);
if (index == -1)
{
return;
}
ZipArchiveEntry entry = archive.Entries[index];
using (StreamReader file = new StreamReader(entry.Open()))
{
JsonSerializer serializer = new JsonSerializer
{
TypeNameHandling = TypeNameHandling.Auto,
ObjectCreationHandling = ObjectCreationHandling.Replace,
Converters = { new BitArrayConverter(), new Vector3Converter(), new WireConverter() }
};
Dictionary <Guid, IntegratedCircuit> components = (Dictionary <Guid, IntegratedCircuit>)serializer.Deserialize(file, typeof(Dictionary <Guid, IntegratedCircuit>));
foreach (Guid g in components.Keys)
{
IntegratedCircuit ic = components[g];
GameObject obj;
switch (ic.IcType)
{
case ICType.solo:
obj = cp.PlaceIntegratedCircuit(ic, ic.GetPinNode(0), ic.GetPinNodeIndex(0), true);
obj.transform.position = CircuitHelper.GetPositionFromNode(ic.GetPinNode(0), ic.GetPinNodeIndex(0));
break;
case ICType.dual:
obj = cp.PlaceIntegratedCircuit(ic, ic.GetPinNode(0), ic.GetPinNodeIndex(0), ic.GetPinNode(1), ic.GetPinNodeIndex(1), true);
Vector3 locationA = CircuitHelper.GetPositionFromNode(ic.GetPinNode(0), ic.GetPinNodeIndex(0));
Vector3 locationB = CircuitHelper.GetPositionFromNode(ic.GetPinNode(1), ic.GetPinNodeIndex(1));
obj.transform.position = new Vector3((locationA.x + locationB.x) / 2, 0, (locationA.z + locationB.z) / 2);
obj.transform.localScale = new Vector3(Vector3.Distance(locationB, locationA) / 2, 1, 1);
float angle = CircuitHelper.AngleBetweenVector3(locationB, locationA);
angle = locationA.z > locationB.z ? -angle : angle;
obj.transform.rotation = Quaternion.Euler(0, angle, 0);
break;
case ICType.ic4:
obj = cp.PlaceIntegratedCircuit(ic, ic.GetPinNode(0), ic.GetPinNodeIndex(0), true);
obj.transform.position = CircuitHelper.GetPositionFromNode(ic.GetPinNode(0), ic.GetPinNodeIndex(0));
break;
case ICType.ic6:
obj = cp.PlaceIntegratedCircuit(ic, ic.GetPinNode(0), ic.GetPinNodeIndex(0), true);
obj.transform.position = CircuitHelper.GetPositionFromNode(ic.GetPinNode(0), ic.GetPinNodeIndex(0));
break;
case ICType.wire:
obj = cp.PlaceIntegratedCircuit(ic, ic.GetPinNode(0), ic.GetPinNodeIndex(0), ic.GetPinNode(1), ic.GetPinNodeIndex(1), true);
Vector3[] vectors = ((Wire)ic).points;
LineRenderer lineRenderer = obj.GetComponentInChildren <LineRenderer>();
lineRenderer.positionCount = vectors.Length;
lineRenderer.SetPositions(vectors);
CircuitHelper.CreateColliderChain(obj, vectors);
break;
default:
break;
}
ic.CustomMethod();
}
}
}
public AndGate(string name, IntegratedCircuit circuit, bool inverted = false, NodeType type = NodeType.internalNode, params LogicNode[] inputs)
: base(name, circuit, inverted, type, inputs)
{
}
public void RemoveBreadBoard(GameObject boardObj)
{
HashSet <string> nodesToDelete = new HashSet <string>();
HashSet <Guid> componentsToDelete = new HashSet <Guid>();
HashSet <Guid> wiresToDelete = new HashSet <Guid>();
for (int i = 0; i < boardObj.transform.childCount; i++)
{
string id = boardObj.transform.GetChild(i).name;
if (id == "none")
{
continue;
}
foreach (string s in breadBoard.nodes.Keys.Where(x => x.StartsWith(id)))
{
nodesToDelete.Add(s);
foreach (Connection c in breadBoard.nodes[s].connections.Values)
{
if (!c.IsNode)
{
componentsToDelete.Add(Guid.Parse(c.ID));
}
}
}
foreach (Guid g in breadBoard.components.Keys)
{
IntegratedCircuit ic = breadBoard.components[g];
if (ic.IcType == ICType.wire)
{
if (ic.GetPinNode(0).StartsWith(id) || ic.GetPinNode(1).StartsWith(id))
{
wiresToDelete.Add(g);
}
}
else if (!ic.WriteToNodes)
{
if (ic.GetPinNode(0).StartsWith(id))
{
componentsToDelete.Add(g);
}
}
}
}
for (int i = breadBoardData.Count - 1; i >= 0; i--)
{
if (boardObj.transform.name == breadBoardData[i].ToString())
{
breadBoardData.RemoveAt(i);
}
}
foreach (Guid g in componentsToDelete)
{
Destroy(breadBoard.components[g].GetObjRef());
circuitPool.RemoveIntegratedCircuit(g.ToString());
}
foreach (Guid g in wiresToDelete)
{
Destroy(breadBoard.components[g].GetObjRef());
circuitPool.RemoveWire(g.ToString());
}
foreach (string s in nodesToDelete)
{
breadBoard.nodes.Remove(s);
}
Destroy(boardObj.transform.gameObject);
}
