public Inc4()
{
input0 = new Nibble();
output0 = new Nibble();
input0.Deletable = false;
input0.Draggable = false;
output0.Deletable = false;
output0.Draggable = false;
one = new Bit();
add = new Add4();
Connections.CrossConnect(input0.OutputPoint0, add.Input0.InputPoint0);
Connections.CrossConnect(input0.OutputPoint1, add.Input0.InputPoint1);
Connections.CrossConnect(input0.OutputPoint2, add.Input0.InputPoint2);
Connections.CrossConnect(input0.OutputPoint3, add.Input0.InputPoint3);
Connections.CrossConnect(one.OutputPoint, add.Input1.InputPoint1);
Connections.CrossConnect(add.Output0.OutputPoint0, output0.InputPoint0);
Connections.CrossConnect(add.Output0.OutputPoint1, output0.InputPoint1);
Connections.CrossConnect(add.Output0.OutputPoint2, output0.InputPoint2);
Connections.CrossConnect(add.Output0.OutputPoint3, output0.InputPoint3);
one.Input = true;
this.Controls.Add(input0);
this.Controls.Add(output0);
this.ContextMenuStrip = cms;
}
float[] lastItemTime; // the time when the last item was created for each band
#endregion Fields
#region Methods
void CreateBits()
{
for (int i = 1; i < equalizer.curedSpectrum.Length -1; i++) {
if (lastCuredSpectrum[i] < equalizer.curedSpectrum[i] && equalizer.curedSpectrum[i] > tolerance && Time.time >= waitTime + lastItemTime[i]) {
Bit tempItem;
float posX = transform.position.x - Game.WorldSize.x + itemSize * i + itemSize/2;
float positionY = Game.WorldSize.y - itemSize/2f - (Bar.unitHeight * Mathf.Clamp(equalizer.curedSpectrum[i], 0f, maxVelocity) / maxVelocity);
int r = Utilities.GetIntByChance(itemChances);
tempItem = Instantiate(bits[r], new Vector3(posX, positionY, transform.position.z),Quaternion.identity) as Bit;
tempItem.transform.parent = transform;
tempItem.InitValues( (0.2f + (Mathf.Log(equalizer.curedSpectrum[i]))) * itemSpeed, i, itemScale);
Bit[] allItemsList = new Bit[transform.childCount];
// make items bigger during their life if frequency is banging
int p = 0;
foreach (Transform child in transform) {
allItemsList[p] = child.gameObject.GetComponent<Bit>();
float tr = allItemsList[p].timeRemaining;
float lt = allItemsList[p].lifetime;
if (allItemsList[p].iSpec == i && tr < lt/3f) {
allItemsList[p].timeRemaining *= 2f;
}
p++;
}
lastItemTime[i] = Time.time;
}
lastCuredSpectrum[i] = equalizer.curedSpectrum[i];
}
}
public NandGate()
{
input0 = new Bit();
input1 = new Bit();
output = new Bit();
input0.BitChanged += new Bit.BitChangedEventHandler(InputChanged);
input1.BitChanged += new Bit.BitChangedEventHandler(InputChanged);
input0.Draggable = false;
input1.Draggable = false;
output.Draggable = false;
input0.Deletable = false;
input1.Deletable = false;
output.Deletable = false;
input0.Bittype = Bit.BitType.Input;
input1.Bittype = Bit.BitType.Input;
output.Bittype = Bit.BitType.Output;
this.Controls.Add(input0);
this.Controls.Add(input1);
this.Controls.Add(output);
this.ContextMenuStrip = cms;
}
public FullSubtractor()
{
input0 = new Bit();
input1 = new Bit();
inputB = new Bit();
outputS = new Bit();
outputB = new Bit();
input0.Draggable = false;
input1.Draggable = false;
inputB.Draggable = false;
outputS.Draggable = false;
outputB.Draggable = false;
input0.Deletable = false;
input1.Deletable = false;
inputB.Deletable = false;
outputS.Deletable = false;
outputB.Deletable = false;
input0.Bittype = Bit.BitType.Input;
input1.Bittype = Bit.BitType.Input;
inputB.Bittype = Bit.BitType.Input;
outputS.Bittype = Bit.BitType.Output;
outputB.Bittype = Bit.BitType.Output;
xor1 = new XOrGate();
xor2 = new XOrGate();
and1 = new AndGate();
and2 = new AndGate();
or1 = new OrGate();
not1 = new NotGate();
not2 = new NotGate();
Connections.CrossConnect(input0.OutputPoint, xor1.InputPoint0);
Connections.CrossConnect(input1.OutputPoint, xor1.InputPoint1);
Connections.CrossConnect(input0.OutputPoint, not1.InputPoint);
Connections.CrossConnect(not1.OutputPoint, and1.InputPoint0);
Connections.CrossConnect(input1.OutputPoint, and1.InputPoint1);
Connections.CrossConnect(xor1.OutputPoint, xor2.InputPoint0);
Connections.CrossConnect(inputB.OutputPoint, xor2.InputPoint1);
Connections.CrossConnect(xor1.OutputPoint, not2.InputPoint);
Connections.CrossConnect(not2.OutputPoint, and2.InputPoint0);
Connections.CrossConnect(inputB.OutputPoint, and2.InputPoint1);
Connections.CrossConnect(xor2.OutputPoint, outputS.InputPoint);
Connections.CrossConnect(and1.OutputPoint, or1.InputPoint0);
Connections.CrossConnect(and2.OutputPoint, or1.InputPoint1);
Connections.CrossConnect(or1.OutputPoint, outputB.InputPoint);
this.Controls.Add(input0);
this.Controls.Add(input1);
this.Controls.Add(inputB);
this.Controls.Add(outputS);
this.Controls.Add(outputB);
this.ContextMenuStrip = cms;
}
public void SetValue(Bit bit, bool value)
{
if (value)
{
this._bits |= bit;
}
else
{
var reverse = (Bit)0x11111111 ^ bit;
this._bits &= reverse;
}
}
public int BitsToInt(Bit[] bits)
{
var value = 0;
foreach (var b in bits) {
value <<= 1;
if (b == Bit.One) {
value |= 0x01;
} else {
value &= ~(0x01);
}
}
return value;
}
public Sub4()
{
input0 = new Nibble();
input1 = new Nibble();
output0 = new Nibble();
borrow = new Bit();
borrow.Bittype = Bit.BitType.Output;
input0.Deletable = false;
input0.Draggable = false;
input1.Deletable = false;
input1.Draggable = false;
output0.Deletable = false;
output0.Draggable = false;
borrow.Deletable = false;
borrow.Draggable = false;
fs1 = new FullSubtractor();
fs2 = new FullSubtractor();
fs3 = new FullSubtractor();
fs4 = new FullSubtractor();
Connections.CrossConnect(input0.OutputPoint0, fs1.Input0);
Connections.CrossConnect(input1.OutputPoint0, fs1.Input1);
Connections.CrossConnect(fs1.OutputB, fs2.InputB);
Connections.CrossConnect(input0.OutputPoint1, fs2.Input0);
Connections.CrossConnect(input1.OutputPoint1, fs2.Input1);
Connections.CrossConnect(fs2.OutputB, fs3.InputB);
Connections.CrossConnect(input0.OutputPoint2, fs3.Input0);
Connections.CrossConnect(input1.OutputPoint2, fs3.Input1);
Connections.CrossConnect(fs3.OutputB, fs4.InputB);
Connections.CrossConnect(input0.OutputPoint3, fs4.Input0);
Connections.CrossConnect(input1.OutputPoint3, fs4.Input1);
Connections.CrossConnect(fs4.OutputB, borrow.InputPoint);
Connections.CrossConnect(fs1.OutputS, output0.InputPoint0);
Connections.CrossConnect(fs2.OutputS, output0.InputPoint1);
Connections.CrossConnect(fs3.OutputS, output0.InputPoint2);
Connections.CrossConnect(fs4.OutputS, output0.InputPoint3);
fs1.InputB.IO = false;
this.Controls.Add(input0);
this.Controls.Add(input1);
this.Controls.Add(output0);
this.Controls.Add(borrow);
this.ContextMenuStrip = cms;
}
public Add4()
{
input0 = new Nibble();
input1 = new Nibble();
output0 = new Nibble();
carry = new Bit();
carry.Bittype = Bit.BitType.Output;
input0.Draggable = false;
input1.Draggable = false;
output0.Draggable = false;
carry.Draggable = false;
input0.Deletable = false;
input1.Deletable = false;
output0.Deletable = false;
carry.Deletable = false;
fa1 = new FullAdder();
fa2 = new FullAdder();
fa3 = new FullAdder();
fa4 = new FullAdder();
Connections.CrossConnect(input0.OutputPoint0, fa1.Input0);
Connections.CrossConnect(input1.OutputPoint0, fa1.Input1);
Connections.CrossConnect(fa1.OutputC, fa2.InputC);
Connections.CrossConnect(input0.OutputPoint1, fa2.Input0);
Connections.CrossConnect(input1.OutputPoint1, fa2.Input1);
Connections.CrossConnect(fa2.OutputC, fa3.InputC);
Connections.CrossConnect(input0.OutputPoint2, fa3.Input0);
Connections.CrossConnect(input1.OutputPoint2, fa3.Input1);
Connections.CrossConnect(fa3.OutputC, fa4.InputC);
Connections.CrossConnect(input0.OutputPoint3, fa4.Input0);
Connections.CrossConnect(input1.OutputPoint3, fa4.Input1);
Connections.CrossConnect(fa4.OutputC, carry.InputPoint);
Connections.CrossConnect(fa1.OutputS, output0.InputPoint0);
Connections.CrossConnect(fa2.OutputS, output0.InputPoint1);
Connections.CrossConnect(fa3.OutputS, output0.InputPoint2);
Connections.CrossConnect(fa4.OutputS, output0.InputPoint3);
fa1.InputC.IO = false;
Controls.Add(input0);
Controls.Add(input1);
Controls.Add(output0);
Controls.Add(carry);
this.ContextMenuStrip = cms;
}
public Nibble()
{
for (int n = 0; n < bits.Length; n++)
{
bits[n] = new Bit("InputPoint"+(n+1), "OutputPoint"+(n+1), this);
bits[n].Name = "bit" + n;
bits[n].Clickable = false;
bits[n].Draggable = false;
bits[n].Deletable = false;
}
this.DeletableChanged += new LogicGate.DeleteableEventHandler(Deletable_Changed);
this.Controls.AddRange(bits);
this.ContextMenuStrip = cms;
}
Bit[] bits; // All the bits for the byte will be stored here
#endregion Fields
#region Constructors
public Byte(int defaultValue)
{
// Convert the data to a binary string
string data = Convert.ToString(defaultValue, 2);
data = pad(data) + data;
if (data.Length != BYTE_SIZE) throw new Exception("Data incorrect length (should be 8 bits, i.e. in the range 0 - 255)...");
char[] num = data.ToCharArray();
Array.Reverse(num);
data = new string(num);
// Read the string and convert into an array of Bit objects
bits = new Bit[BYTE_SIZE];
for (int i = 0; i < BYTE_SIZE; i++)
{
if (data[i] == '1') bits[i] = new Bit(true);
else bits[i] = new Bit(false);
}
}
public static void WriteBit(this BinaryWriter bw, Bit bit)
{
bw.Write((bool)bit);
}
public Bit mod(Bit x) { return new Bit(m && !x.m); }
public bool eq(Bit x) { return m == x.m; }
public bool lteq(Bit x) { return !m || x.m; }
public BitContainer(int intValue)
{
this._bits = (Bit)intValue;
}
public bool GetValue(Bit bit)
{
return (this._bits & bit) == bit;
}
public static Bit add_bit(Bit x, Bit y) { return x.add(y); }
public static Bit mod_bit(Bit x, Bit y) { return x.mod(y); }
public Bit div(Bit x) { return new Bit(m && !x.m); }
public static Bit sub_bit(Bit x, Bit y) { return x.sub(y); }
public static Bit mul_bit(Bit x, Bit y) { return x.mul(y); }
public static bool neq_bit(Bit x, Bit y) { return !x.eq(y); }
public static Bit compl_bit(Bit x) { return new Bit(!x.m); }
protected void setSize(Bit bit)
{
if (this.Size.Equals(LGComponent.small)) bit.Size = Bit.small;
else if (this.Size.Equals(LGComponent.medium)) bit.Size = Bit.medium;
else bit.Size = Bit.large;
}
/* =========================================================================================
* Create Inputs
* =========================================================================================
*/
private void bitToolStripMenuItem_Click(object sender, EventArgs e)
{
Bit g = new Bit();
g.Location = calcLocation();
g.Size = s.Equals(LogicGate.small) ? Bit.small : s.Equals(LogicGate.medium) ? Bit.medium : Bit.large;
g.Input = false;
//g.ContextMenuStrip = cmsControl;
g.Name = g.GetType().Name + namecntr++;
this.Controls.Add(g);
}
protected void UpdateBitLocation(Bit bit, int offsetX, float offsetY)
{
bit.Location = new Point(offsetX, (int)(this.Height * offsetY) - bit.Height / 2);
bit.UpdateLocation(
new PointF(this.Location.X + bit.Location.X + bit.Width / 2, this.Location.Y + bit.Location.Y + bit.Height / 2),
new PointF(this.Location.X + bit.Location.X + bit.Width / 2, this.Location.Y + bit.Location.Y + bit.Height / 2),
false
);
}
public static Bit div_bit(Bit x, Bit y) { return x.div(y); }
public FloatParts ToFloatParts(FloatDescription desc, Bit[] bits)
{
if (bits.Length != desc.BitCount) {
throw new Exception("not enough bits");
}
var e = new List<Bit>();
var f = new List<Bit>();
if (desc.ExponentBits > 0) {
e = bits.Skip(1).Take(desc.ExponentBits).ToList();
}
if (desc.SignificandBits > 0) {
f = bits.Skip(1 + desc.ExponentBits).ToList();
}
var parts = new FloatParts {
Sign = bits[0],
Exponent = e.ToArray(),
Fraction = f.ToArray()
};
return parts;
}
public Bit sub(Bit x) { return new Bit(m && !x.m); }
protected void setSize(Bit bit)
{
if (this.Size.Equals(LogicGate.small)) bit.Size = Bit.small;
else if (this.Size.Equals(LogicGate.medium)) bit.Size = Bit.medium;
else bit.Size = Bit.large;
}
public static void HandleCreatureQueryResponse(Packet packet)
{
var entry = packet.ReadEntry("Entry");
CreatureTemplate creature = new CreatureTemplate
{
Entry = (uint)entry.Key
};
Bit hasData = packet.ReadBit();
if (!hasData)
{
return; // nothing to do
}
creature.ModelIDs = new uint?[4];
creature.KillCredits = new uint?[2];
creature.RacialLeader = packet.ReadBit("Racial Leader");
uint bits2C = packet.ReadBits(6);
var stringLens = new int[4][];
for (int i = 0; i < 4; i++)
{
stringLens[i] = new int[2];
stringLens[i][1] = (int)packet.ReadBits(11);
stringLens[i][0] = (int)packet.ReadBits(11);
}
uint qItemCount = packet.ReadBits(22);
uint bits24 = packet.ReadBits(11);
uint bits1C = packet.ReadBits(11);
creature.ManaModifier = packet.ReadSingle("Modifier 2");
var name = new string[4];
var femaleName = new string[4];
for (int i = 0; i < 4; ++i)
{
if (stringLens[i][0] > 1)
{
name[i] = packet.ReadCString("Name", i);
}
if (stringLens[i][1] > 1)
{
femaleName[i] = packet.ReadCString("Female Name", i);
}
}
creature.Name = name[0];
creature.FemaleName = femaleName[0];
creature.HealthModifier = packet.ReadSingle("Modifier 1");
creature.KillCredits[1] = packet.ReadUInt32();
creature.ModelIDs[2] = packet.ReadUInt32();
//TODO: move to creature_questitems
//creature.QuestItems = new uint[qItemCount];
for (int i = 0; i < qItemCount; ++i)
{
/*creature.QuestItems[i] = (uint)*/ packet.ReadInt32 <ItemId>("Quest Item", i);
}
creature.Type = packet.ReadInt32E <CreatureType>("Type");
if (bits2C > 1)
{
creature.IconName = packet.ReadCString("Icon Name");
}
creature.TypeFlags = packet.ReadUInt32E <CreatureTypeFlag>("Type Flags");
creature.TypeFlags2 = packet.ReadUInt32("Creature Type Flags 2"); // Missing enum
creature.KillCredits[0] = packet.ReadUInt32();
creature.Family = packet.ReadInt32E <CreatureFamily>("Family");
creature.MovementID = packet.ReadUInt32("Movement ID");
creature.RequiredExpansion = packet.ReadUInt32E <ClientType>("Expansion");
creature.ModelIDs[0] = packet.ReadUInt32();
creature.ModelIDs[1] = packet.ReadUInt32();
if (bits1C > 1)
{
packet.ReadCString("String");
}
creature.Rank = packet.ReadInt32E <CreatureRank>("Rank");
if (bits24 > 1)
{
creature.SubName = packet.ReadCString("Sub Name");
}
creature.ModelIDs[3] = packet.ReadUInt32();
for (int i = 0; i < 4; ++i)
{
packet.AddValue("Display ID", creature.ModelIDs[i], i);
}
for (int i = 0; i < 2; ++i)
{
packet.AddValue("Kill Credit", creature.KillCredits[i], i);
}
packet.AddSniffData(StoreNameType.Unit, entry.Key, "QUERY_RESPONSE");
Storage.CreatureTemplates.Add(creature, packet.TimeSpan);
ObjectName objectName = new ObjectName
{
ObjectType = ObjectType.Unit,
ID = entry.Key,
Name = creature.Name
};
Storage.ObjectNames.Add(objectName, packet.TimeSpan);
}
