public CompT CompHermano <CompT> (bool siNecesarioActivo = false) where CompT : MonoBehaviour, IComp { IComp tcomp = null; if (transform.parent != null) { IComp [] tCompsPadre = transform.parent.GetComponents <IComp> (); if (tCompsPadre != null) { foreach (IComp tCompPadre in tCompsPadre) { /*if ( tCompPadre.GetType () == typeof ( CompT ) ) { * return ( CompT ) tCompPadre; * } */ tcomp = tCompPadre.CompHijo <CompT> (siNecesarioActivo); if (tcomp == null) { tcomp = tCompPadre.CompHermano <CompT> (siNecesarioActivo); } if (tcomp != null) { return((CompT)tcomp); } } } } return(( CompT )tcomp); }
public override void OnVibrate(IComp Comp, string Contact, object Val) { if (Contacts[Contact] == Comp) { Values[Contact] = Val; } }
public override void DisconnectWith(IComp Comp, string Contact) { if (Contacts.ContainsKey(Contact)) { Contacts.Remove(Contact); Comp.DisconnectWith(this, Contact); } }
public static Entity Replace <TComponent, TValue>(this Entity entity, IComp <TComponent, SingleValueComponent <TValue> .Editor> compData, TValue value) where TComponent : SingleValueComponent <TValue>, new() { TComponent comp = entity.CreateComponent <TComponent>(compData.EntitasData.Id); compData.Editor.SetActionReplace(entity, compData.EntitasData.Id, comp); return(compData.Editor.Apply(value)); }
public static CConduit Connect(IComp A, IComp B, string Contact) { var C = new CConduit(); C.Connect(A, Contact); C.Connect(B, Contact); return(C); }
public static CConduit Link(IComp Comp1, String C1, String C2, IComp Comp2) { var Con = new CConduit(); Con.Connect(Comp1, C1); Con.Connect(Comp2, C2); return(Con); }
public static TEditor Replace <TComponent, TEditor>(this Entity entity, IComp <TComponent, TEditor> compData) where TComponent : IComponent, new() where TEditor : IComponentEditor <TComponent> { TComponent comp = entity.CreateComponent <TComponent>(compData.EntitasData.Id); compData.Editor.SetActionReplace(entity, compData.EntitasData.Id, comp); return(compData.Editor); }
public override void DisconnectWith(IComp Comp, string Contact) { IComp C = Ports.Contacts[Contact]; if (C != null) { IComp V; Ports.Contacts.TryRemove(Contact, out V); Comp.DisconnectWith(this, Contact); } }
public override void OnVibrate(IComp Comp, string Contact, object Val) { if (Contact == "IN" && Contacts["IN"] == Comp) { var C = Contacts["OUT"]; if (C != null) { C.OnVibrate(this, Contact, Val); } } }
public override void DisconnectWith(IComp Comp, string Contact) { var idx = Contacts.FindIndex((pair) => { return(pair.Key == Contact && pair.Value == Comp); }); if (idx >= 0) { Contacts.RemoveAt(idx); } }
private static Operand GetIntComparison( EmitterContext context, IComp cond, Operand srcA, Operand srcB, bool isSigned, bool extended) { return(extended ? GetIntComparisonExtended(context, cond, srcA, srcB, isSigned) : GetIntComparison(context, cond, srcA, srcB, isSigned)); }
public override void Connect(IComp Comp, string Contact) { var idx = Contacts.FindIndex((pair) => { return(pair.Key == Contact && pair.Value == Comp); }); if (idx < 0) { Contacts.Add(new KeyValuePair <string, IComp>(Contact, Comp)); Comp.Connect(this, Contact); } }
private static void EmitIcmp( EmitterContext context, IComp cmpOp, Operand srcA, Operand srcB, Operand srcC, int rd, bool isSigned) { Operand cmpRes = GetIntComparison(context, cmpOp, srcC, Const(0), isSigned); Operand res = context.ConditionalSelect(cmpRes, srcA, srcB); context.Copy(GetDest(rd), res); }
void AsignarCompHijos() { componentes = new List <IComp> (); for (int cmp = 0; cmp < transform.childCount; cmp++) { IComp comp = transform.GetChild(cmp).GetComponent <IComp> (); if (comp != null) { componentes.Add(comp); if (cmp > 0) { comp.CompEntrada = componentes [cmp - 1]; } } } }
public override void Connect(IComp Comp, string Contact) { var C = Contacts[Contact]; if (C != null) { if (C != Comp) { C.Connect(Comp, Contact); } } else { Contacts[Contact] = Comp; } }
public override void OnVibrate(IComp Comp, string Contact, object Val) { foreach (var pair in Contacts) { if (pair.Value != Comp && pair.Key != Contact) { if (ParallelTrx) { new Thread(() => AsyncVirbrate(this, pair, Val)).Start(); } else { pair.Value.OnVibrate(this, pair.Key, Val); } } } }
private static Operand GetIntComparison(EmitterContext context, IComp cond, Operand srcA, Operand srcB, bool isSigned) { Operand res; if (cond == IComp.T) { res = Const(IrConsts.True); } else if (cond == IComp.F) { res = Const(IrConsts.False); } else { var inst = cond switch { IComp.Lt => Instruction.CompareLessU32, IComp.Eq => Instruction.CompareEqual, IComp.Le => Instruction.CompareLessOrEqualU32, IComp.Gt => Instruction.CompareGreaterU32, IComp.Ne => Instruction.CompareNotEqual, IComp.Ge => Instruction.CompareGreaterOrEqualU32, _ => throw new InvalidOperationException($"Unexpected condition \"{cond}\".") }; if (isSigned) { switch (cond) { case IComp.Lt: inst = Instruction.CompareLess; break; case IComp.Le: inst = Instruction.CompareLessOrEqual; break; case IComp.Gt: inst = Instruction.CompareGreater; break; case IComp.Ge: inst = Instruction.CompareGreaterOrEqual; break; } } res = context.Add(inst, Local(), srcA, srcB); } return(res); } }
public override void OnVibrate(IComp Comp, string Contact, object Val) { var C = Contacts[Contact]; if (C == Comp) { Sem.WaitOne(); Collections.Add(Val); if (Collections.Count == MAX) { var Col = Collections; foreach (var c in Contacts.Keys) { Contacts[c].OnVibrate(this, c, Col); } } Sem.Release(); } }
public override void Connect(IComp Comp, string Contact) { if (Contact != "IN" && Contact != "OUT") { throw new Exception("Only contacts available are IN and OUT"); } var C = Contacts[Contact]; if (C != null) { if (C != Comp) { C.Connect(Comp, Contact); } } else { Contacts[Contact] = Comp; } }
public override void OnVibrate(IComp Comp, string Contact, object Val) { if (Ins == null || Ins.Length == 0) { this.FX(this); } var IsInput = Ins.Contains(Contact); if (IsInput) { bool Already = false; if (Stage) { Sem.WaitOne(); Already = _HasInput.ContainsKey(Contact); _HasInput[Contact] = true; Ports.Values[Contact] = Val; if (!Already && ++ICount == Ins.Length) { this.FX(this, Contact); _HasInput.Clear(); ICount = 0; } Sem.Release(); } else { Already = _HasInput.ContainsKey(Contact); _HasInput[Contact] = true; Ports.Values[Contact] = Val; if (!Already && ++ICount >= Ins.Length || ICount >= Ins.Length ) { this.FX(this, Contact); } } } }
public override void Connect(IComp Comp, string Contact) { if (++Initialized == 1) { this.InitFX(this); } if (Ports.Contacts.ContainsKey(Contact)) { var EComp = Ports.Contacts[Contact]; if (EComp != Comp) { EComp.Connect(Comp, Contact); } } else { Ports.Contacts[Contact] = Comp; Comp.Connect(this, Contact); } }
private static void EmitIsetp( EmitterContext context, IComp cmpOp, BoolOp logicOp, Operand srcA, Operand srcB, int srcPred, bool srcPredInv, int destPred, int destPredInv, bool isSigned, bool extended) { Operand p0Res = GetIntComparison(context, cmpOp, srcA, srcB, isSigned, extended); Operand p1Res = context.BitwiseNot(p0Res); Operand pred = GetPredicate(context, srcPred, srcPredInv); p0Res = GetPredLogicalOp(context, logicOp, p0Res, pred); p1Res = GetPredLogicalOp(context, logicOp, p1Res, pred); context.Copy(Register(destPred, RegisterType.Predicate), p0Res); context.Copy(Register(destPredInv, RegisterType.Predicate), p1Res); }
internal EntitasDataSummary(Type containingType) { FieldInfo[] fields = containingType.GetFields(); ComponentNames = new string[fields.Length]; ComponentTypes = new Type[fields.Length]; IList <IComp> comps = new List <IComp>(); foreach (FieldInfo field in fields) { IComp comp = (IComp)field.GetValue(null); // force jit call constructor on each component comps.Add(comp); } for (int i = 0; i < fields.Length; ++i) { EntitasData data = comps[i].EntitasData; data.Id = i; ComponentNames[i] = data.name; ComponentTypes[i] = data.type; var matcher = (Matcher)Matcher.AllOf(i); matcher.componentNames = ComponentNames; data.Match = matcher; } }
private static void EmitIset( EmitterContext context, IComp cmpOp, BoolOp logicOp, Operand srcA, Operand srcB, int srcPred, bool srcPredInv, int rd, bool boolFloat, bool isSigned, bool extended, bool writeCC) { Operand res = GetIntComparison(context, cmpOp, srcA, srcB, isSigned, extended); Operand pred = GetPredicate(context, srcPred, srcPredInv); res = GetPredLogicalOp(context, logicOp, res, pred); Operand dest = GetDest(rd); if (boolFloat) { res = context.ConditionalSelect(res, ConstF(1), Const(0)); context.Copy(dest, res); SetFPZnFlags(context, res, writeCC); } else { context.Copy(dest, res); SetZnFlags(context, res, writeCC, extended); } }
public override void DisconnectWith(IComp Comp, string Contact) { }
public override void Connect(IComp Comp, string Contact) { }
public static void AsyncVirbrate(IComp From, KeyValuePair <String, IComp> Pair, Object Val) { Pair.Value.OnVibrate(From, Pair.Key, Val); }
public static bool Has(this Entity entity, IComp compData) { return(entity.HasComponent(compData.EntitasData.Id)); }
public static Entity Remove(this Entity entity, IComp <object> compData) { return(entity.RemoveComponent(compData.EntitasData.Id)); }
public static TValue GetValue <TValue>(this Entity entity, IComp <ISingleValueComponent <TValue>, object> compData) { ISingleValueComponent <TValue> component = (ISingleValueComponent <TValue>)entity.GetComponent(compData.EntitasData.Id); return(component.Value); }