548 lines
19 KiB
JavaScript
548 lines
19 KiB
JavaScript
class LogicWireNode extends Element {
|
|
constructor(_Container, RestoreData = null, logicengine) {
|
|
super(_Container, RestoreData,logicengine,1);
|
|
this.removeProperty("Inputs");
|
|
this.Name = "WireNode";
|
|
this.Width = 20;
|
|
this.Height = 20;
|
|
}
|
|
getOutput(Output = 0) {
|
|
if (Output > 0) return false;
|
|
return this.Inputs[0];
|
|
}
|
|
drawElement(x,y,ctx) {
|
|
if (this.LogicEngine.ActiveContainer !== this._Container) return; // No point if we aren't visible
|
|
this.StaticCanvas.width = this.Width;
|
|
this.StaticCanvas.height = this.Height;
|
|
|
|
this.drawInputs(ctx,x,y,undefined,undefined,undefined,undefined,true);
|
|
this.drawOutputs(ctx,x,y,undefined,undefined,undefined,undefined,true);
|
|
}
|
|
}
|
|
let ElementCatalog_WireNode = new ElementCatalog_Element("WireNode","A simple compact wire node for organizing wiring","-O-",LogicWireNode,[]);
|
|
ElementReferenceTable.push(ElementCatalog_WireNode);
|
|
ElementCategory_Other.addElement(ElementCatalog_WireNode);
|
|
|
|
class LogicAND extends Element {
|
|
constructor(_Container, RestoreData = null, logicengine,Inputs) {
|
|
super(_Container, RestoreData,logicengine,Inputs);
|
|
this.Name = "AND";
|
|
}
|
|
|
|
getOutput(Output=0) {
|
|
if (super.getOutput() === 0) return false;
|
|
let ANDResult = true;
|
|
for (let a = 0; a < this.totalInputs();a++) {
|
|
if (!this.Inputs[a]) ANDResult = false;
|
|
}
|
|
return ANDResult;
|
|
}
|
|
|
|
drawElement(x,y,ctx) {
|
|
if (this.LogicEngine.ActiveContainer !== this._Container) return; // No point if we aren't visible
|
|
this.StaticCanvas.width = this.Width;
|
|
this.StaticCanvas.height = this.Height;
|
|
|
|
//this.drawBorderBox(ctx, x+10,y,this.Width-20,this.Height);
|
|
let xOffset = 20;
|
|
let shadowColor = this.LogicEngine.Settings.ShadowColor;
|
|
ctx.save();
|
|
ctx.beginPath();
|
|
ctx.moveTo(x+xOffset,y);
|
|
ctx.lineTo((x+xOffset)+ this.Width/4,y);
|
|
ctx.quadraticCurveTo(x+(this.Width - xOffset),y,x+(this.Width-xOffset),y+(this.Height/2));
|
|
ctx.quadraticCurveTo(x+(this.Width - xOffset),y+this.Height,(x+xOffset)+ this.Width/4,y+this.Height);
|
|
ctx.lineTo(x+xOffset,y+this.Height);
|
|
ctx.lineTo(x+xOffset,y);
|
|
ctx.lineWidth = "3";
|
|
ctx.fillStyle = "#f7e979";
|
|
ctx.shadowColor = shadowColor;
|
|
ctx.shadowBlur = "6";
|
|
ctx.shadowOffsetX = 2;
|
|
ctx.shadowOffsetY = 2;
|
|
ctx.stroke();
|
|
ctx.fill();
|
|
ctx.restore();
|
|
this.drawTextCentered(ctx,x,y,this.Width,this.Height,this.Designator,"12px Console","#000");
|
|
this.drawInputs(ctx,x,y,undefined,undefined,undefined,undefined,true);
|
|
this.drawOutputs(ctx,x,y,undefined,undefined,undefined,undefined,true);
|
|
}
|
|
}
|
|
let ElementCatalog_AND = new ElementCatalog_Element("AND","The AND gate only outputs high when all of the inputs are high.","&",LogicAND,[2]);
|
|
ElementReferenceTable.push(ElementCatalog_AND);
|
|
ElementCategory_LOGIC.addElement(ElementCatalog_AND);
|
|
|
|
class LogicNAND extends LogicAND {
|
|
constructor(_Container, RestoreData = null, logicengine,Inputs) {
|
|
super(_Container, RestoreData,logicengine,Inputs);
|
|
this.Name = "NAND";
|
|
this.Width = 110;
|
|
}
|
|
|
|
getOutput(Output=0) {
|
|
if (this.Disconnecting) return false;
|
|
if (super.getOutput()) {
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
drawElement(x,y,ctx) {
|
|
if (this.LogicEngine.ActiveContainer !== this._Container) return; // No point if we aren't visible
|
|
this.StaticCanvas.width = this.Width;
|
|
this.StaticCanvas.height = this.Height;
|
|
|
|
let xOffset = 20;
|
|
let shadowColor = this.LogicEngine.Settings.ShadowColor;
|
|
ctx.save();
|
|
ctx.beginPath();
|
|
ctx.moveTo(x+xOffset,y);
|
|
ctx.lineTo((x+xOffset)+ this.Width/4,y);
|
|
ctx.quadraticCurveTo(x+(this.Width - (xOffset*1.5)),y,x+(this.Width-(xOffset*1.5)),y+(this.Height/2));
|
|
ctx.quadraticCurveTo(x+(this.Width - (xOffset*1.5)),y+this.Height,(x+xOffset)+ this.Width/4,y+this.Height);
|
|
ctx.lineTo(x+xOffset,y+this.Height);
|
|
ctx.lineTo(x+xOffset,y);
|
|
ctx.lineWidth = "3";
|
|
ctx.fillStyle = "#f7e979";
|
|
ctx.strokeStyle = "#000000";
|
|
ctx.shadowColor = shadowColor;
|
|
ctx.shadowBlur = "6";
|
|
ctx.shadowOffsetX = 2;
|
|
ctx.shadowOffsetY = 2;
|
|
ctx.stroke();
|
|
ctx.fill();
|
|
|
|
ctx.beginPath();
|
|
ctx.fillStyle = "#000000";
|
|
ctx.strokeStyle = "#000000";
|
|
ctx.lineWidth = "1";
|
|
ctx.arc(x + (this.Width - 25),y + (this.Height/2),5,0,2*Math.PI);
|
|
ctx.stroke();
|
|
ctx.fill();
|
|
|
|
ctx.restore();
|
|
this.drawTextCentered(ctx,x,y,this.Width-xOffset,this.Height,this.Designator,"12px Console","#000");
|
|
this.drawInputs(ctx,x,y,undefined,undefined,undefined,undefined,true);
|
|
this.drawOutputs(ctx,x,y,undefined,undefined,undefined,undefined,true);
|
|
}
|
|
}
|
|
let ElementCatalog_NAND = new ElementCatalog_Element("NAND","The NAND gate always outputs a high signal unless all the inputs are high then it goes low.","!&",LogicNAND,[2]);
|
|
ElementReferenceTable.push(ElementCatalog_NAND);
|
|
ElementCategory_LOGIC.addElement(ElementCatalog_NAND);
|
|
|
|
class LogicOR extends Element {
|
|
constructor(_Container, RestoreData = null, logicengine,Inputs) {
|
|
super(_Container, RestoreData,logicengine,Inputs);
|
|
this.Name = "OR";
|
|
}
|
|
|
|
getOutput(Output=0) {
|
|
if (super.getOutput() === 0) return false;
|
|
let ORResult = false;
|
|
for (let a = 0; a < this.totalInputs();a++) {
|
|
if (this.Inputs[a]) ORResult = true;
|
|
}
|
|
return ORResult;
|
|
}
|
|
drawElement(x,y,ctx) {
|
|
if (this.LogicEngine.ActiveContainer !== this._Container) return; // No point if we aren't visible
|
|
this.StaticCanvas.width = this.Width;
|
|
this.StaticCanvas.height = this.Height;
|
|
|
|
let drawWidth = this.Width;
|
|
let drawHeight = this.Height;
|
|
let xOffset = 20;
|
|
let shadowColor = this.LogicEngine.Settings.ShadowColor;
|
|
|
|
ctx.save();
|
|
ctx.beginPath();
|
|
ctx.moveTo(x+(xOffset/4),y);
|
|
ctx.lineTo((x+xOffset)+ this.Width/4,y);
|
|
ctx.quadraticCurveTo(x+(this.Width - (xOffset*2)),y,x+(this.Width-xOffset),y+(this.Height/2));
|
|
ctx.quadraticCurveTo(x+(this.Width - (xOffset*2)),y+this.Height,(x+xOffset)+ this.Width/4,y+this.Height);
|
|
ctx.lineTo(x+(xOffset/4),y+this.Height);
|
|
ctx.quadraticCurveTo(x+(xOffset+5),y+(this.Height - (this.Height/32)),x+xOffset+5,y+(this.Height/2));
|
|
ctx.quadraticCurveTo(x+(xOffset+5),y+(this.Height/32),x+(xOffset/4),y);
|
|
ctx.lineWidth = "3";
|
|
ctx.fillStyle = "#f7e979";
|
|
ctx.shadowColor = shadowColor;
|
|
ctx.shadowBlur = "6";
|
|
ctx.shadowOffsetX = 2;
|
|
ctx.shadowOffsetY = 2;
|
|
ctx.stroke();
|
|
ctx.fill();
|
|
ctx.restore();
|
|
|
|
this.drawTextCentered(ctx,x,y,this.Width,this.Height,this.Designator,"12px Console","#000");
|
|
this.drawInputs(ctx,x,y,undefined,undefined,undefined,undefined,true);
|
|
this.drawOutputs(ctx,x,y,undefined,undefined,undefined,undefined,true);
|
|
}
|
|
}
|
|
let ElementCatalog_OR = new ElementCatalog_Element("OR","The OR gate outputs a high when any input is HIGH.","|",LogicOR,[2]);
|
|
ElementReferenceTable.push(ElementCatalog_OR);
|
|
ElementCategory_LOGIC.addElement(ElementCatalog_OR);
|
|
|
|
class LogicNOR extends LogicOR {
|
|
constructor(_Container, RestoreData = null, logicengine,Inputs) {
|
|
super(_Container, RestoreData,logicengine,Inputs);
|
|
this.Name = "NOR";
|
|
this.Width = 110;
|
|
}
|
|
getOutput(Output=0) {
|
|
if (super.getOutput() === 0) return false;
|
|
if (super.getOutput()) {
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
drawElement(x,y,ctx) {
|
|
if (this.LogicEngine.ActiveContainer !== this._Container) return; // No point if we aren't visible
|
|
this.StaticCanvas.width = this.Width;
|
|
this.StaticCanvas.height = this.Height;
|
|
|
|
let xOffset = 20;
|
|
let shadowColor = this.LogicEngine.Settings.ShadowColor;
|
|
|
|
ctx.save();
|
|
ctx.beginPath();
|
|
ctx.moveTo(x+(xOffset/4),y);
|
|
ctx.lineTo((x+xOffset)+ this.Width/4,y);
|
|
ctx.quadraticCurveTo(x+(this.Width - (xOffset*2.5)),y,x+(this.Width-(xOffset*1.5)),y+(this.Height/2));
|
|
ctx.quadraticCurveTo(x+(this.Width - (xOffset*2.5)),y+this.Height,(x+xOffset)+ this.Width/4,y+this.Height);
|
|
ctx.lineTo(x+(xOffset/4),y+this.Height);
|
|
ctx.quadraticCurveTo(x+(xOffset+5),y+(this.Height - (this.Height/32)),x+xOffset+5,y+(this.Height/2));
|
|
ctx.quadraticCurveTo(x+(xOffset+5),y+(this.Height/32),x+(xOffset/4),y);
|
|
ctx.lineWidth = "3";
|
|
ctx.fillStyle = "#f7e979";
|
|
ctx.shadowColor = shadowColor;
|
|
ctx.shadowBlur = "6";
|
|
ctx.shadowOffsetX = 2;
|
|
ctx.shadowOffsetY = 2;
|
|
ctx.stroke();
|
|
ctx.fill();
|
|
|
|
ctx.beginPath();
|
|
ctx.fillStyle = "#000000";
|
|
ctx.strokeStyle = "#000000";
|
|
ctx.lineWidth = "1";
|
|
ctx.arc(x + (this.Width - 25),y + (this.Height/2),5,0,2*Math.PI);
|
|
ctx.stroke();
|
|
ctx.fill();
|
|
|
|
ctx.restore();
|
|
|
|
this.drawTextCentered(ctx,x,y,this.Width-xOffset,this.Height,this.Designator,"12px Console","#000");
|
|
this.drawInputs(ctx,x,y,undefined,undefined,undefined,undefined,true);
|
|
this.drawOutputs(ctx,x,y,undefined,undefined,undefined,undefined,true);
|
|
}
|
|
}
|
|
let ElementCatalog_NOR = new ElementCatalog_Element("NOR","The NOR gate outputs a high only when all inputs are low.","!|",LogicNOR,[2]);
|
|
ElementReferenceTable.push(ElementCatalog_NOR);
|
|
ElementCategory_LOGIC.addElement(ElementCatalog_NOR);
|
|
|
|
class LogicXOR extends Element {
|
|
constructor(_Container, RestoreData = null, logicengine) {
|
|
super(_Container, RestoreData,logicengine,2); // Only 2 inputs on XOR
|
|
this.Name = "XOR";
|
|
this.removeProperty("Inputs");
|
|
}
|
|
|
|
getOutput(Output=0) {
|
|
if (super.getOutput() === 0) return false;
|
|
let ORResult = false;
|
|
if ( (this.Inputs[0] && !this.Inputs[1]) || (!this.Inputs[0] && this.Inputs[1]) ) ORResult = true;
|
|
return ORResult;
|
|
}
|
|
|
|
drawElement(x,y,ctx) {
|
|
if (this.LogicEngine.ActiveContainer !== this._Container) return; // No point if we aren't visible
|
|
this.StaticCanvas.width = this.Width;
|
|
this.StaticCanvas.height = this.Height;
|
|
|
|
let drawWidth = this.Width;
|
|
let drawHeight = this.Height;
|
|
|
|
let xOffset = 20;
|
|
let shadowColor = this.LogicEngine.Settings.ShadowColor;
|
|
|
|
ctx.save();
|
|
ctx.beginPath();
|
|
ctx.moveTo(x+(xOffset/4),y);
|
|
ctx.lineTo((x+xOffset)+ this.Width/4,y);
|
|
ctx.quadraticCurveTo(x+(this.Width - (xOffset*2)),y,x+(this.Width-xOffset),y+(this.Height/2));
|
|
ctx.quadraticCurveTo(x+(this.Width - (xOffset*2)),y+this.Height,(x+xOffset)+ this.Width/4,y+this.Height);
|
|
ctx.lineTo(x+(xOffset/4),y+this.Height);
|
|
ctx.quadraticCurveTo(x+(xOffset+5),y+(this.Height - (this.Height/32)),x+xOffset+5,y+(this.Height/2));
|
|
ctx.quadraticCurveTo(x+(xOffset+5),y+(this.Height/32),x+(xOffset/4),y);
|
|
ctx.lineWidth = "3";
|
|
ctx.fillStyle = "#f7e979";
|
|
ctx.shadowColor = shadowColor;
|
|
ctx.shadowBlur = "6";
|
|
ctx.shadowOffsetX = 2;
|
|
ctx.shadowOffsetY = 2;
|
|
ctx.stroke();
|
|
ctx.fill();
|
|
|
|
ctx.lineWidth = "2";
|
|
ctx.beginPath();
|
|
ctx.shadowColor = "transparent";
|
|
ctx.moveTo(x+(xOffset/4)+10,y+this.Height);
|
|
ctx.quadraticCurveTo(x+(xOffset+10),y+(this.Height - (this.Height/32)),x+xOffset+10,y+(this.Height/2));
|
|
ctx.quadraticCurveTo(x+(xOffset+10),y+(this.Height/32),x+(xOffset/4)+10,y);
|
|
ctx.stroke();
|
|
|
|
ctx.beginPath();
|
|
ctx.moveTo(x+(xOffset/4),y+this.Height);
|
|
ctx.quadraticCurveTo(x+(xOffset+5),y+(this.Height - (this.Height/32)),x+xOffset+5,y+(this.Height/2));
|
|
ctx.quadraticCurveTo(x+(xOffset+5),y+(this.Height/32),x+(xOffset/4),y);
|
|
ctx.stroke();
|
|
ctx.restore();
|
|
|
|
this.drawTextCentered(ctx,x,y,this.Width,this.Height,this.Designator,"12px Console","#000");
|
|
this.drawInputs(ctx,x,y,undefined,undefined,undefined,undefined,true);
|
|
this.drawOutputs(ctx,x,y,undefined,undefined,undefined,undefined,true);
|
|
}
|
|
}
|
|
let ElementCatalog_XOR = new ElementCatalog_Element("XOR","The XOR gate outputs a high when only 1 input is high.","^",LogicXOR,[]);
|
|
ElementReferenceTable.push(ElementCatalog_XOR);
|
|
ElementCategory_LOGIC.addElement(ElementCatalog_XOR);
|
|
|
|
class LogicXNOR extends Element {
|
|
constructor(_Container, RestoreData = null, logicengine) {
|
|
super(_Container, RestoreData,logicengine,2); // Only 2 inputs on XOR
|
|
this.Name = "XNOR";
|
|
this.removeProperty("Inputs");
|
|
this.Width = 110;
|
|
}
|
|
|
|
getOutput(Output=0) {
|
|
if (super.getOutput() === 0) return false;
|
|
let ORResult = false;
|
|
if ( (this.Inputs[0] && !this.Inputs[1]) || (!this.Inputs[0] && this.Inputs[1]) ) ORResult = true;
|
|
return !ORResult;
|
|
}
|
|
|
|
drawElement(x,y,ctx) {
|
|
if (this.LogicEngine.ActiveContainer !== this._Container) return; // No point if we aren't visible
|
|
this.StaticCanvas.width = this.Width;
|
|
this.StaticCanvas.height = this.Height;
|
|
|
|
let drawWidth = this.Width;
|
|
let drawHeight = this.Height;
|
|
|
|
let xOffset = 20;
|
|
let shadowColor = this.LogicEngine.Settings.ShadowColor;
|
|
|
|
ctx.save();
|
|
ctx.beginPath();
|
|
ctx.save();
|
|
ctx.beginPath();
|
|
ctx.moveTo(x+(xOffset/4),y);
|
|
ctx.lineTo((x+xOffset)+ this.Width/4,y);
|
|
ctx.quadraticCurveTo(x+(this.Width - (xOffset*2.5)),y,x+(this.Width-(xOffset*1.5)),y+(this.Height/2));
|
|
ctx.quadraticCurveTo(x+(this.Width - (xOffset*2.5)),y+this.Height,(x+xOffset)+ this.Width/4,y+this.Height);
|
|
ctx.lineTo(x+(xOffset/4),y+this.Height);
|
|
ctx.quadraticCurveTo(x+(xOffset+5),y+(this.Height - (this.Height/32)),x+xOffset+5,y+(this.Height/2));
|
|
ctx.quadraticCurveTo(x+(xOffset+5),y+(this.Height/32),x+(xOffset/4),y);
|
|
ctx.lineWidth = "3";
|
|
ctx.fillStyle = "#f7e979";
|
|
ctx.shadowColor = shadowColor;
|
|
ctx.shadowBlur = "6";
|
|
ctx.shadowOffsetX = 2;
|
|
ctx.shadowOffsetY = 2;
|
|
ctx.stroke();
|
|
ctx.fill();
|
|
|
|
ctx.beginPath();
|
|
ctx.fillStyle = "#000000";
|
|
ctx.strokeStyle = "#000000";
|
|
ctx.lineWidth = "1";
|
|
ctx.arc(x + (this.Width - 25),y + (this.Height/2),5,0,2*Math.PI);
|
|
ctx.stroke();
|
|
ctx.fill();
|
|
|
|
ctx.lineWidth = "2";
|
|
ctx.beginPath();
|
|
ctx.shadowColor = "transparent";
|
|
ctx.moveTo(x+(xOffset/4)+10,y+this.Height);
|
|
ctx.quadraticCurveTo(x+(xOffset+10),y+(this.Height - (this.Height/32)),x+xOffset+10,y+(this.Height/2));
|
|
ctx.quadraticCurveTo(x+(xOffset+10),y+(this.Height/32),x+(xOffset/4)+10,y);
|
|
ctx.stroke();
|
|
|
|
ctx.beginPath();
|
|
ctx.moveTo(x+(xOffset/4),y+this.Height);
|
|
ctx.quadraticCurveTo(x+(xOffset+5),y+(this.Height - (this.Height/32)),x+xOffset+5,y+(this.Height/2));
|
|
ctx.quadraticCurveTo(x+(xOffset+5),y+(this.Height/32),x+(xOffset/4),y);
|
|
ctx.stroke();
|
|
ctx.restore();
|
|
|
|
this.drawTextCentered(ctx,x,y,this.Width-(xOffset/2),this.Height,this.Designator,"10px Console","#000");
|
|
this.drawInputs(ctx,x,y,undefined,undefined,undefined,undefined,true);
|
|
this.drawOutputs(ctx,x,y,undefined,undefined,undefined,undefined,true);
|
|
}
|
|
}
|
|
|
|
let ElementCatalog_XNOR = new ElementCatalog_Element("XNOR","The XNOR gate outputs a high only when both inputs are either low or high.","!^",LogicXNOR,[]);
|
|
ElementReferenceTable.push(ElementCatalog_XNOR);
|
|
ElementCategory_LOGIC.addElement(ElementCatalog_XNOR);
|
|
|
|
class LogicNOT extends Element {
|
|
constructor(_Container, RestoreData = null, logicengine) {
|
|
super(_Container, RestoreData,logicengine,1); // Only 1 inputs on NOT
|
|
this.Name = "NOT";
|
|
this.removeProperty("Inputs");
|
|
this.Width = 110;
|
|
}
|
|
|
|
getOutput(Output=0) {
|
|
if (super.getOutput() === 0) return false;
|
|
if (this.Inputs[0]) return false;
|
|
return true;
|
|
}
|
|
|
|
drawElement(x,y,ctx) {
|
|
if (this.LogicEngine.ActiveContainer !== this._Container) return; // No point if we aren't visible
|
|
this.StaticCanvas.width = this.Width;
|
|
this.StaticCanvas.height = this.Height;
|
|
|
|
let drawWidth = this.Width;
|
|
let drawHeight = this.Height;
|
|
|
|
let xOffset = 20;
|
|
let shadowColor = this.LogicEngine.Settings.ShadowColor;
|
|
|
|
ctx.save();
|
|
ctx.beginPath();
|
|
ctx.moveTo(x+xOffset,y);
|
|
ctx.lineTo(x+(this.Width-(xOffset+10)),y+(this.Height/2));
|
|
ctx.lineTo(x+xOffset,y+this.Height);
|
|
ctx.lineTo(x+xOffset,y);
|
|
ctx.lineWidth = "3";
|
|
ctx.fillStyle = "#f7e979";
|
|
ctx.shadowColor = shadowColor;
|
|
ctx.shadowBlur = "6";
|
|
ctx.shadowOffsetX = 2;
|
|
ctx.shadowOffsetY = 2;
|
|
ctx.stroke();
|
|
ctx.fill();
|
|
|
|
ctx.beginPath();
|
|
ctx.fillStyle = "#000000";
|
|
ctx.strokeStyle = "#000000";
|
|
ctx.lineWidth = "1";
|
|
ctx.arc(x + (this.Width - 25),y + (this.Height/2),5,0,2*Math.PI);
|
|
ctx.stroke();
|
|
ctx.fill();
|
|
|
|
ctx.restore();
|
|
this.drawTextCentered(ctx,x,y,this.Width-(xOffset),this.Height,this.Designator,"12px Console","#000");
|
|
this.drawInputs(ctx,x,y,undefined,undefined,undefined,undefined,true);
|
|
this.drawOutputs(ctx,x,y,undefined,undefined,undefined,undefined,true);
|
|
}
|
|
}
|
|
let ElementCatalog_NOT = new ElementCatalog_Element("NOT","The NOT gate outputs the opposite of the input.","!",LogicNOT,[]);
|
|
ElementReferenceTable.push(ElementCatalog_NOT);
|
|
ElementCategory_LOGIC.addElement(ElementCatalog_NOT);
|
|
|
|
class LogicBuffer extends Element {
|
|
ClockTick() {
|
|
this.Output = this.Inputs[0];
|
|
this.Task.Enabled = false;
|
|
this.Task.LastCall = 0;
|
|
|
|
for (let a = 0; a < this.OutputConnections.length; a++) {
|
|
this.LogicEngine.RecursionCount = 0;
|
|
this.OutputConnections[a].Element.setInput(this.OutputConnections[a].Input, this.getOutput());
|
|
}
|
|
this.drawElement(0,0,this.StaticCtx);
|
|
}
|
|
|
|
Delete() {
|
|
super.Delete();
|
|
this.LogicEngine.Scheduler.deleteTask(this.Task);
|
|
}
|
|
|
|
getOutput(Output=0) {
|
|
if (super.getOutput() === 0) return false;
|
|
return this.Output;
|
|
}
|
|
|
|
setInput(Input, Value) {
|
|
if (Input > 0) return;
|
|
//super.setInput(Input, Value);
|
|
Value = this._Container.isHigh(this,Input);
|
|
if (Value !== false) Value = true;
|
|
this.Inputs[Input] = Value;
|
|
this.redraw = true;
|
|
|
|
if (!this.Task.Enabled) {
|
|
this.Task.LastCall = 0;
|
|
this.Task.Enabled = true;
|
|
}
|
|
this.drawElement(0,0,this.StaticCtx);
|
|
}
|
|
|
|
constructor(_Container, RestoreData = null, logicengine) {
|
|
super(_Container, RestoreData,logicengine,1);
|
|
this.removeProperty("Inputs");
|
|
this.Output = false;
|
|
this.Name = "Buffer";
|
|
this.Width = 100;
|
|
this.Task = new Task("BufferTask","Buffer",0,9999999,this.ClockTick.bind(this));
|
|
this.Task.Time = 4;
|
|
this.Task.Enabled = false;
|
|
this.Task.LastCall = 0;
|
|
this.removeProperty("Inputs");
|
|
if (RestoreData) this.Output = RestoreData.Output;
|
|
this.LogicEngine.Scheduler.addTask(this.Task);
|
|
}
|
|
|
|
toJSON(key) {
|
|
let superjson = super.toJSON(key);
|
|
superjson.Task = {
|
|
Enabled: this.Task.Enabled,
|
|
Time: this.Task.Time,
|
|
LastCall: Date.now() - this.Task.LastCall,
|
|
CallCount: this.Task.CallCount
|
|
};
|
|
return superjson;
|
|
}
|
|
|
|
|
|
drawElement(x, y, ctx) {
|
|
if (this.LogicEngine.ActiveContainer !== this._Container) return; // No point if we aren't visible
|
|
this.StaticCanvas.width = this.Width;
|
|
this.StaticCanvas.height = this.Height;
|
|
|
|
let drawWidth = this.Width;
|
|
let drawHeight = this.Height;
|
|
|
|
let xOffset = 20;
|
|
let shadowColor = this.LogicEngine.Settings.ShadowColor;
|
|
|
|
ctx.save();
|
|
ctx.beginPath();
|
|
ctx.moveTo(x+xOffset,y);
|
|
ctx.lineTo(x+(this.Width-(xOffset)),y+(this.Height/2));
|
|
ctx.lineTo(x+xOffset,y+this.Height);
|
|
ctx.lineTo(x+xOffset,y);
|
|
ctx.lineWidth = "3";
|
|
ctx.fillStyle = "#f7e979";
|
|
ctx.shadowColor = shadowColor;
|
|
ctx.shadowBlur = "6";
|
|
ctx.shadowOffsetX = 2;
|
|
ctx.shadowOffsetY = 2;
|
|
ctx.stroke();
|
|
ctx.fill();
|
|
ctx.restore();
|
|
this.drawTextCentered(ctx,x,y,this.Width-(xOffset),this.Height,this.Designator,"12px Console","#000");
|
|
this.drawInputs(ctx,x,y,undefined,undefined,undefined,undefined,true);
|
|
this.drawOutputs(ctx,x,y,undefined,undefined,undefined,undefined,true);
|
|
}
|
|
}
|
|
let ElementCatalog_BUFFER = new ElementCatalog_Element("Buffer","The buffer is a special gate to allow the prevention of recursion loops.","|>",LogicBuffer,[]);
|
|
ElementReferenceTable.push(ElementCatalog_BUFFER);
|
|
ElementCategory_LOGIC.addElement(ElementCatalog_BUFFER);
|