public void update(GameTime gameTime)
{
if (!_paused || _singleStep)
{
string levelUid = LevelSystem.currentLevelUid;
EventSystem eventSystem = _systemManager.getSystem(SystemType.Event) as EventSystem;
List <int> circuitEntities = _entityManager.getEntitiesPosessing(levelUid, ComponentType.Circuit);
for (int i = 0; i < circuitEntities.Count; i++)
{
CircuitComponent circuitComponent = _entityManager.getComponent(levelUid, circuitEntities[i], ComponentType.Circuit) as CircuitComponent;
foreach (Gate gate in circuitComponent.circuit.gates)
{
if (gate.type == "output")
{
OutputGate outputGate = gate as OutputGate;
if (outputGate.postEvent)
{
GateOutputComponent outputComponent = _entityManager.getComponent(levelUid, outputGate.entityId, ComponentType.GateOutput) as GateOutputComponent;
GameEventType eventType = outputGate.state ? outputComponent.onEnabledEvent : outputComponent.onDisabledEvent;
eventSystem.postEvent(new GameEvent(eventType, outputGate.entityId));
}
outputGate.postEvent = false;
}
}
}
}
_singleStep = false;
}
public DeleteCircuitStatus DeleteCircuit(int ID)
{
try
{
if (CaseComponent.IsCaseConnectedToCircuit(ID))
{
return(DeleteCircuitStatus.CaseConnectedToCircuit);
}
//if (CircuitComponent.IsStartDateAfterToday(ID)==false)
//{
// return DeleteCircuitStatus.CircuitStartDateBeforeToday;
//}
else
{
using (var Transaction = BeginDatabaseTransaction())
{
var r1 = CircuitRollsComponent.DeleteCircuitRollsByCircuitID(ID);
var r2 = CircuitMembersComponent.DeleteCircuitMemberByCircuitID(ID);
PoliceComp.DeleteCircuitPoliceStations(ID);
CircuitComponent.DeleteCircuit(ID);
if (Transaction != null)
{
Transaction.Commit();
}
return(DeleteCircuitStatus.Deleted);
}
}
}
catch (Exception ex)
{
HandleException(ex);
return(DeleteCircuitStatus.NotDeleted);
}
}
public override void RefreshTile(Vector3Int location, ITilemap tilemap)
{
if (tilemap.GetTile(location))
{
Circuit.AddComponent(location, new Wire(location, tilemap));
}
else
{
Circuit.RemoveComponent(location);
}
tilemap.RefreshTile(location);
if (Circuit.circuitComponents.ContainsKey(location))
{
CircuitComponent component = Circuit.circuitComponents[location];
foreach (CircuitComponent inComponent in component.ins)
{
tilemap.RefreshTile(inComponent.location);
}
foreach (CircuitComponent outComponent in component.outs)
{
tilemap.RefreshTile(outComponent.location);
}
}
}
bool checkForwardCircuits(NodePosition sourcePosition, ref Type[,] connections, Direction initialDirection, ref HashSet <NodePosition> discovered)
{
shortCircuit = false;
bool finished = false;
validPath = new Stack <NodePosition>();
//checks if children made a correct connection to goal or not
bool notConnected = false;
//begin initializing Stack search case with first source node
List <NodePosition> adjacentConnectors = CircuitComponent.adjMatrix(sourcePosition, initialDirection);
switch (initialDirection)
{
case Direction.Left:
break;
case Direction.Up:
break;
case Direction.Right:
break;
case Direction.Down:
break;
}
return(false);
}
public override void RefreshTile(Vector3Int location, ITilemap tilemap)
{
realTilemap = tilemap.GetComponent <Tilemap>();
TileBase previousTile;
Circuit.RemoveComponent(location);
tilemap.RefreshTile(location);
if (tilemap.GetTile <OrTile>(location))
{
TrueOrTile orGate = ScriptableObject.CreateInstance <TrueOrTile>();
orGate.gateWireSprites = trueOrSprites;
previousTile = tilemap.GetTile(location + new Vector3Int(-1, 0, 0));
orGate.replacedTile = previousTile;
realTilemap.SetTile(location + new Vector3Int(-1, 0, 0), orGate);
}
else
{
CircuitComponent component = Circuit.circuitComponents[location + new Vector3Int(-1, 0, 0)];
if (component is OrGate)
{
LogicGate gate = (LogicGate)component;
realTilemap.SetTile(location + new Vector3Int(-1, 0, 0), gate.previousTile);
}
}
}
public void Chain(string transitionName, CircuitComponent component)
{
if (transitions == null)
{
transitions = new List <CircuitDictionaryItem>();
}
foreach (CircuitDictionaryItem item in transitions)
{
if (item.transitionName == transitionName)
{
if (item.transition == null)
{
item.transition = new List <CircuitComponent>();
}
item.transition.Add(component);
return;
}
}
CircuitDictionaryItem newItem = new CircuitDictionaryItem();
newItem.transitionName = transitionName;
newItem.transition = new List <CircuitComponent>();
newItem.transition.Add(component);
transitions.Add(newItem);
}
public override void RefreshTile(Vector3Int location, ITilemap tilemap)
{
if (tilemap.GetTile(location))
{
OrGate gate = new OrGate(location, tilemap);
Circuit.AddComponent(location, gate);
gate.previousTile = replacedTile;
}
else
{
Circuit.RemoveComponent(location);
}
tilemap.RefreshTile(location);
if (Circuit.circuitComponents.ContainsKey(location))
{
CircuitComponent component = Circuit.circuitComponents[location];
foreach (CircuitComponent inComponent in component.ins)
{
tilemap.RefreshTile(inComponent.location);
}
foreach (CircuitComponent outComponent in component.outs)
{
tilemap.RefreshTile(outComponent.location);
}
}
}
public SaveCircuitStatus EditCircuit(vw_CircuitData circuitData)
{
try
{
DateTime EndCircuitDate = new DateTime(DateTime.Today.Year, SystemConfigurations.Settings_CircuitEndMonth, SystemConfigurations.Settings_CircuitEndDay);
bool isSameYearCircuit = (circuitData.CircuitStartDate < EndCircuitDate || (circuitData.CircuitStartDate > EndCircuitDate && DateTime.Today > EndCircuitDate) ? true : false);
DateTime CircuitEndDate = new DateTime(circuitData.CircuitStartDate.Year, SystemConfigurations.Settings_CircuitEndMonth, SystemConfigurations.Settings_CircuitEndDay);
if (circuitData.CircuitStartDate > CircuitEndDate)
{
CircuitEndDate = circuitData.CircuitStartDate.AddYears(1);
}
//if (CircuitComponent.IsStartDateAfterToday(circuitData.ID) == false)
//{
// return SaveCircuitStatus.CircuitStartDateBeforeToday;
//}
if (ValidateJudges(circuitData.JudgesID))
{
return(SaveCircuitStatus.Judge_Used_Twice);
}
if (CircuitComponent.IsSavedBefore(isSameYearCircuit, circuitData.CircuitName, circuitData.ID))
{
return(SaveCircuitStatus.Saved_Before);
}
circuitData.IsActive = isSameYearCircuit;
circuitData.IsFutureCircuit = !isSameYearCircuit;
using (var Transaction = BeginDatabaseTransaction())
{
PoliceComp.DeleteCircuitPoliceStations(circuitData.ID);
PoliceComp.SaveCircuitPoliceStations(circuitData.PoliceStations, circuitData.ID);
CircuitMembersComponent.EditCircuitJudges(circuitData.JudgesID, circuitData.ID, circuitData.CircuitStartDate);
//CircuitMembersComponent.DeleteCircuitMemberByCircuitID (circuitData.ID);
//CircuitMembersComponent.AddCircuitJudges ( circuitData.JudgesID ,circuitData.ID,circuitData.CircuitStartDate );
CircuitComponent.EditCircuit(circuitData);
if (Transaction != null)
{
Transaction.Commit();
}
return(SaveCircuitStatus.Saved_Successfully);
}
}
catch (DbEntityValidationException ex)
{
HandleException(ex);
return(SaveCircuitStatus.Failed_To_Save);
}
}
public Charge(CircuitComponent component, bool crossing)
{
this.Component = component;
this.ComponentCoords = component.Coords;
this.Crossing = crossing;
}
public void BFS()
{
int maxIterations = 100;
HashSet <CircuitComponent> visited = new HashSet <CircuitComponent>();
HashSet <CircuitComponent> gates = new HashSet <CircuitComponent>();
Queue <CircuitComponent> componentQueue = new Queue <CircuitComponent>();
CircuitComponent currentComponent = this;
componentQueue.Enqueue(currentComponent);
bool foundInput = false;
while (componentQueue.Count != 0 && maxIterations > 0)
{
maxIterations--;
currentComponent = componentQueue.Dequeue();
visited.Add(currentComponent);
// si encuentra un input prendido
if (currentComponent is InputComponent && currentComponent.on)
{
foundInput = true;
}
else if (currentComponent is LogicGate || currentComponent is NotGate)
{
gates.Add(currentComponent);
}
else
{
// cambie de ins a outs
foreach (CircuitComponent neighbor in currentComponent.ins)
{
if (!visited.Contains(neighbor))
{
componentQueue.Enqueue(neighbor);
}
}
foreach (CircuitComponent neighbor in currentComponent.outs)
{
if (!visited.Contains(neighbor) && (neighbor is LogicGate || neighbor is NotGate || neighbor is OutputComponent))
{
gates.Add(currentComponent);
}
}
}
}
foreach (CircuitComponent component in visited)
{
component.on = foundInput;
tilemap.RefreshTile(component.location);
}
foreach (CircuitComponent gate in gates)
{
gate.Turn(gate.CheckIns());
}
}
public vw_CircuitsGrid GetCircuitsFullDataByID(int CircuitID)
{
vw_CircuitsGrid CObj = CircuitComponent.GetCircuitsFullDataByID(CircuitID);
CObj.CircuitMembers = CircuitMembersComponent.GetCircuitMembersByCircuitID(CObj.ID);
CObj.PoliceStations = PsComponent.GetPoliceStationsByCircuitID(CObj.ID);
return(CObj);
}
void Dfs(NodePosition position, Direction dir)
{
List <NodePosition> list = CircuitComponent.adjMatrix(position, dir);
int dirRep = 0;
switch (dir)
{
case Direction.Left:
dirRep = 0;
break;
case Direction.Up:
dirRep = 1;
break;
case Direction.Right:
dirRep = 2;
break;
case Direction.Down:
dirRep = 3;
break;
}
int count = 0;
foreach (NodePosition pos in list)
{
if (connections[pos.x, pos.y] == Type.Wires)
{
Dfs(pos, direction [dirRep][count]);
break;
}
else if (connections[pos.x, pos.y] == Type.Goal)
{
lightBulbPass++;
Dfs(pos, direction [dirRep][count]);
break;
}
else if (connections[pos.x, pos.y] == Type.Battery)
{
if (lightBulbPass >= numberOfLightBulb)
{
Debug.Log(lightBulbPass);
win = true;
}
else
{
win = false;
}
}
else if (count <= 2)
{
count++;
}
}
}
internal Instruction(string fullInput, CircuitComponent left, string logicOp, CircuitComponent right,
CircuitComponent answer)
{
FullInput = fullInput;
LeftValue = left;
LogicOperator = logicOp;
RightValue = right;
AnswerValue = answer;
}
// When component is added to the breadboard
public void OnTriggerEnter(Collider other)
{
if (!other.CompareTag("Hand") && other.gameObject.GetComponent <CircuitComponent>())
{
if (other.gameObject.GetComponent <CircuitComponent>().componentType != "wire")
{
circComponent = other.gameObject.GetComponent <CircuitComponent>();
}
}
}
public List <vw_CircuitsGrid> GetCircuitsFullData(int CourtID)
{
List <vw_CircuitsGrid> CircuitsList = CircuitComponent.GetCircuitsFullData(CourtID);
foreach (vw_CircuitsGrid CObj in CircuitsList)
{
CObj.CircuitMembers = CircuitMembersComponent.GetCircuitMembersByCircuitID(CObj.ID);
CObj.PoliceStations = PsComponent.GetPoliceStationsByCircuitID(CObj.ID);
}
return(CircuitsList);
}
private List <CircuitComponent> GetListOfWires(List <Instruction> listOfInstructions)
{
var wires = new List <CircuitComponent>();
foreach (var item in listOfInstructions)
{
var wire = new CircuitComponent(item.AnswerValue.Name);
wires.Add(wire);
}
return(wires.Distinct().ToList());
}
public void Insert(int x, int y, CircuitComponent circuitComponent)
{
if (strips[x, y] == null)
{
//DebugLog.instance.Write("Inserting component" + x + "," + y);
strips[x, y] = circuitComponent;
componentsPlaced += 1;
if (circuitComponent.componentType == "led")
{
circuitComponent.id = idCounter;
leds.Add(idCounter, circuitComponent);
}
if (circuitComponent.componentType == "wire")
{
circuitComponent.id = idCounter;
wires.Add(idCounter, circuitComponent);
}
if (circuitComponent.componentType == "7404")
{
circuitComponent.id = idCounter;
icsFour.Add(idCounter, circuitComponent);
}
if (circuitComponent.componentType == "7408")
{
circuitComponent.id = idCounter;
icsEight.Add(idCounter, circuitComponent);
}
if (circuitComponent.componentType == "switch")
{
circuitComponent.id = idCounter;
switches.Add(idCounter, circuitComponent);
}
ProcedureManager.instance.CheckSteps(this);
idCounter += 1;
}
}
public override void GetTileData(Vector3Int location, ITilemap tilemap, ref TileData tileData)
{
if (!Circuit.circuitComponents.ContainsKey(location))
{
return;
}
CircuitComponent component = Circuit.circuitComponents[location];
HashSet <Vector3Int> borders = new HashSet <Vector3Int>();
foreach (CircuitComponent inComponent in component.ins)
{
borders.Add(inComponent.location);
}
foreach (CircuitComponent outComponent in component.outs)
{
borders.Add(outComponent.location);
}
int mask = borders.Contains(location + new Vector3Int(0, 1, 0)) ? 1 : 0;
mask += borders.Contains(location + new Vector3Int(1, 0, 0)) ? 2 : 0;
mask += borders.Contains(location + new Vector3Int(0, -1, 0)) ? 4 : 0;
mask += borders.Contains(location + new Vector3Int(-1, 0, 0)) ? 8 : 0;
mask += borders.Contains(location + new Vector3Int(-2, 0, 0)) ? 16 : 0;
int index = GetIndex((byte)mask);
if (index >= 0 && index < wireSprites.Length)
{
tileData.sprite = wireSprites[index];
}
else
{
Debug.LogWarning("Not enough sprites in WireTile instance, recieved index: " + index);
}
if (Circuit.circuitComponents[location].on)
{
tileData.sprite = wireSprites[0];
}
}
public MainForm(ComponentManager componentManager)
{
InitializeComponent();
Text = Program.Caption;
var random = new Random(Environment.TickCount);
_components = new LinkedList <BaseComponent>();
var com = new CircuitComponent(componentManager.Components.Skip(1).FirstOrDefault(), "test");
com.Name += " - " + com.Resource.Name;
com.Position = new Point(schematicSurface.ClientSize.Width / 2, schematicSurface.ClientSize.Height / 2);
com.MyNode = _components.AddLast(com);
/*int j = 1;
* for (int i = 0; i < 10; ++i)
* {
* foreach (var res in componentManager.Components)
* {
* var pos = new Point(
* random.Next(schematicSurface.ClientSize.Width),
* random.Next(schematicSurface.ClientSize.Height));
*
* var com = new CircuitComponent(string.Format("#{0} - ", j++), res);
* com.Name += com.Resource.Name;
* com.Position = pos;
* com.MyNode = _components.AddLast(com);
* }
* }*/
schematicSurface.CircuitComponents = _components;
schematicSurface.ComponentSelectionChanged += schematicSurface_ComponentSelectionChanged;
schematicSurface.RequestDeleteComponent += schematicSurface_RequestDeleteComponent;
}
private List <Instruction> FormatInstructions(List <string> inputList)
{
var instructions = new List <Instruction>();
foreach (var line in inputList)
{
var rgx =
@"(?-i)(?<leftValue>[a-z0-9]*)?? ?(?<logicOperator>RSHIFT|LSHIFT|OR|NOT|AND)?? ?(?<rightValue>[a-z0-9]*)?? ?-> (?<answerValue>[a-z0-9]*)";
var matches = Regex.Match(line, rgx).Groups;
var left = new CircuitComponent(matches["leftValue"].Value);
var logic = matches["logicOperator"].Value;
var right = new CircuitComponent(matches["rightValue"].Value);
var answer = new CircuitComponent(matches["answerValue"].Value);
var instruction = new Instruction(line, left, logic, right, answer);
instructions.Add(instruction);
}
return(instructions);
}
// Use this for initialization
void Start()
{
circuitComponent = GetComponent <CircuitComponent>();
}
// public Circuit(Tilemap _tilemap)
// {
// tilemap = _tilemap;
// circuitComponents = new Dictionary<Vector3Int, CircuitComponent>();
// }
public static void AddComponent(Vector3Int location, CircuitComponent component)
{
RemoveComponent(location);
circuitComponents.Add(location, component);
component.Connect();
}
public List <vw_KeyValue> GetCircuitsByCrime(int CrimeID, int CourtID)
{
return(CircuitComponent.GetCircuitsByCrime(CrimeID, CourtID));
}
public List <vw_KeyValue> GetCircuitsBySecretairyID(int SecretairyID)
{
return(CircuitComponent.GetCircuitsBySecretairyID(SecretairyID));
}
public List <CircuitComponent> GenerateComponents()
{
CircuitComponent[] components = new CircuitComponent[Descriptions.Count];
for (int i = 0; i < Descriptions.Count; i++)
{
ICComponentDescription iccd = Descriptions[i];
CircuitComponent dc = null;
switch (iccd.Type)
{
case "ANDGateLogic":
dc = new MinimalLogicGate(new ANDGateLogic());
break;
case "NANDGateLogic":
dc = new MinimalLogicGate(new NANDGateLogic());
break;
case "ORGateLogic":
dc = new MinimalLogicGate(new ORGateLogic());
break;
case "NORGateLogic":
dc = new MinimalLogicGate(new NORGateLogic());
break;
case "XORGateLogic":
dc = new MinimalLogicGate(new XORGateLogic());
break;
case "XNORGateLogic":
dc = new MinimalLogicGate(new XNORGateLogic());
break;
case "NOTGateLogic":
dc = new MinimalLogicGate(new NOTGateLogic());
break;
case "Switch":
//CircuitSwitch cs = new CircuitSwitch(Vector2.Zero);
//cs.SetID(iccd.ID);
dc = new MinimalSwitch()
{
ID = iccd.ID
};
break;
case "Lamp":
//CircuitLamp cl = new CircuitLamp(Vector2.Zero);
//cl.SetID(iccd.ID);
dc = new MinimalLamp()
{
ID = iccd.ID
};
break;
default:
// It is not a built in thing - look for it in the IC files folder
ICDescription icd = iccd.Description;
dc = new DrawableIC(Vector2.Zero, icd.Name, icd, false);
break;
}
components[i] = dc;
}
for (int i = 0; i < Descriptions.Count; i++)
{
ICComponentDescription iccd = Descriptions[i];
foreach (ICConnectionDescription connection in iccd.To)
{
CircuitWire cw = new CircuitWire();
components[i].AddOutputWire(connection.OutIndex, cw);
components[connection.To].SetInputWire(connection.InIndex, cw);
}
}
return(components.ToList());
}
public List <vw_KeyValue> GetCircuitsByCourtID(int courtID)
{
return(CircuitComponent.GetCircuitsByCourtID(courtID));
}
public List <vw_KeyValue> GetCircuits()
{
return(CircuitComponent.GetCircuits());
}
public Charge(CircuitComponent component)
{
this.Component = component;
this.ComponentCoords = component.Coords;
}
/// <summary>
/// Execute the DC simulation
/// </summary>
/// <param name="ckt">The circuit</param>
/// <param name="reset">Restart the circuit if true</param>
public override void Execute(Circuit ckt)
{
// Setup the state
var state = ckt.State;
var rstate = state.Real;
state.UseIC = false; // UseIC is only used in transient simulations
state.UseDC = true;
state.UseSmallSignal = false;
state.Domain = CircuitState.DomainTypes.None;
// Initialize
CircuitComponent[] components = new CircuitComponent[Sweeps.Count];
Parameter <double>[] parameters = new Parameter <double> [Sweeps.Count];
int[] values = new int[Sweeps.Count];
// Initialize first time
for (int i = 0; i < Sweeps.Count; i++)
{
// Get the component to be swept
var sweep = Sweeps[i];
if (!ckt.Components.Contains(sweep.ComponentName))
{
throw new CircuitException($"Could not find source {sweep.ComponentName}");
}
components[i] = ckt.Components[sweep.ComponentName];
// Get the parameter and save it for restoring later
parameters[i] = (Parameter <double>)components[i].GetParameter <double>("dc").Clone();
// Start with the original values
components[i].Set("dc", sweep.Start);
values[i] = 0;
}
// Execute the sweeps
int level = Sweeps.Count - 1;
while (level >= 0)
{
// Fill the values with start values
while (level < Sweeps.Count - 1)
{
level++;
values[level] = 0;
components[level].Set("dc", Sweeps[level].Start);
}
// Calculate the solution
if (!this.Iterate(ckt, MyConfig.MaxIterations))
{
IterationFailed?.Invoke(this, ckt);
this.Op(ckt, MyConfig.MaxIterations);
}
// Export data
Export(ckt);
// Remove all values that are equal to the maximum value
while (level >= 0 && values[level] >= Sweeps[level].Limit)
{
level--;
}
// Go to the next step for the top level
if (level >= 0)
{
values[level]++;
double newvalue = Sweeps[level].Start + values[level] * Sweeps[level].Step;
components[level].Set("dc", newvalue);
}
}
// Restore all the parameters of the swept components
for (int i = 0; i < Sweeps.Count; i++)
{
components[i].GetParameter <double>("dc").CopyFrom(parameters[i]);
}
}
public SaveCircuitStatus AddCircuit(vw_CircuitData circuitData, out int CircuitID)
{
try
{
DateTime EndCircuitDate = new DateTime(DateTime.Today.Year, SystemConfigurations.Settings_CircuitEndMonth, SystemConfigurations.Settings_CircuitEndDay);
if (DateTime.Today > EndCircuitDate)
{
EndCircuitDate.AddYears(1);
}
bool isSameYearCircuit = (circuitData.CircuitStartDate < EndCircuitDate) ? true : false;
DateTime CircuitEndDate = new DateTime(circuitData.CircuitStartDate.Year, SystemConfigurations.Settings_CircuitEndMonth, SystemConfigurations.Settings_CircuitEndDay);
if (circuitData.CircuitStartDate > CircuitEndDate)
{
CircuitEndDate = circuitData.CircuitStartDate.AddYears(1);
}
if (ValidateJudges(circuitData.JudgesID))
{
CircuitID = 0;
return(SaveCircuitStatus.Judge_Used_Twice);
}
if (circuitData.SecretaryID == circuitData.AssistantSecretaryID)
{
CircuitID = 0;
return(SaveCircuitStatus.Secretary_Used_Twice);
}
if (CircuitComponent.IsSavedBefore(isSameYearCircuit, circuitData.CircuitName, circuitData.ID))
{
CircuitID = 0;
return(SaveCircuitStatus.Saved_Before);
}
circuitData.IsActive = isSameYearCircuit;
circuitData.IsFutureCircuit = !isSameYearCircuit;
if (circuitData.AssistantSecretaryID == 0)
{
circuitData.AssistantSecretaryID = null;
}
using (var Transaction = BeginDatabaseTransaction())
{
CircuitComponent.AddCircuit(circuitData, out CircuitID);
PoliceComp.SaveCircuitPoliceStations(circuitData.PoliceStations, CircuitID);
SaveCircuitStatus SaveJudgesStatus = CircuitMembersComponent.AddCircuitJudges(circuitData.JudgesID, CircuitID, circuitData.CircuitStartDate);
if (Transaction != null)
{
Transaction.Commit();
}
return(SaveCircuitStatus.Saved_Successfully);
}
}
catch (Exception ex)
{
CircuitID = 0;
HandleException(ex);
return(SaveCircuitStatus.Failed_To_Save);
}
}
