public ChemicalElement[] GetPrimariesOf(ChemicalElementEntity ent) { ChemicalToArrayData data = this.primaries.Find(x => x.element == ent.type); if (data.array != null) { return(data.array); } else { Debug.LogWarning($"WARNING : This element ({ent.type}) is not yet registered ! Check it out !"); return(null); } }
protected internal static ChemicalElementEntity MixTwoElement(ChemicalElementEntity a, ChemicalElementEntity b) { if (a.type == ChemicalElement.Void) { return(b); } else if (b.type == ChemicalElement.Void) { return(a); } if (InteractiveEngine.instance.HasMixOf(a, b)) { string name = InteractiveEngine.instance.GetMixOf(a, b); if (name == null) { return(null); } Type t = Type.GetType(name); return(Activator.CreateInstance(t, ChemicalElementMixEntity.STANDARD_PARAMS) as ChemicalElementEntity); } List <ChemicalElementMixEntity> candidates = null; ChemicalElementEntity winner = null; candidates = InteractiveEngine.instance.chemicalElementMixEntityPoolList; foreach (ChemicalElementMixEntity mix in ChemicalElementMixEntity.mixes) { if (mix.type != a.type && mix.type != b.type && mix.CouldBeMadeOf(a, b)) { candidates.Add(mix); } } if (candidates.Count > 0) { winner = candidates[0]; for (int i = 1; i < candidates.Count; ++i) { winner = GetWinnerBetween(winner, candidates[i]); } } candidates.Clear(); InteractiveEngine.instance.SetMixOf(a, b, winner); return((winner != null) ? Spawn(winner) : null); }
/* ---------------------------------------------------------------------------------------------*/ /* ---------------------------------------------------------------------------------------------*/ /* ---------------------------------------------------------------------------------------------*/ /* ---------------------------------------- * OPERATOR -----------------------------------------*/ /* ---------------------------------------------------------------------------------------------*/ /* ---------------------------------------------------------------------------------------------*/ /* ---------------------------------------------------------------------------------------------*/ // ELEMENT * ELEMENT public static ChemicalElementEntity operator *(ChemicalElementEntity a, ChemicalElementEntity b) { if (a.type == b.type) { a.intensity = b.intensity = a.intensity + b.intensity; return(a); } ChemicalElementEntity m = ChemicalElementMixEntity.MixTwoElement(a, b); if (m != null) { return(m); } return(ChemicalElementEntity.GetWinnerBetween(a, b)); }
public bool IsWinningAgainst(ChemicalElementEntity main, ChemicalElementEntity other) { int couple = (int)(main.type | other.type); IntToChemicalData data = this.winners.Find(x => x.couple == couple); if (data.couple > 0) { return(data.type == main.type); } else { Debug.LogWarning($"WARNING : This couple ({main} + {other}) is not yet registered ! Check it out !"); return(false); } }
private static void Reaction(InteractiveEntity main, ChemicalElementEntity element, PhysicalInteractionEntity interaction) { InteractiveStatus status; // Calculate reaction : // 1. Result between 'current physical state' and 'possible element' // For example : Frozen * Fire = Neutral; Water status = main.physical * element; // Update entity interactive status main.physical = status.state; main.chemical = status.element; // main manage its new status && the interaction with the unknown entity main.InteractWith(status, interaction); }
/* ---------------------------------------------------------------------------------------------*/ /* ---------------------------------------------------------------------------------------------*/ /* ---------------------------------------------------------------------------------------------*/ /* -------------------------------------- STATIC METHODS ---------------------------------------*/ /* ---------------------------------------------------------------------------------------------*/ /* ---------------------------------------------------------------------------------------------*/ /* ---------------------------------------------------------------------------------------------*/ private protected static ChemicalElementEntity GetWinnerBetween(ChemicalElementEntity a, ChemicalElementEntity b) { if (a.IsStrongAgainst(b)) { return(a); } else if (b.IsStrongAgainst(a)) { return(b); } else if (a.intensity != b.intensity) { return((a.intensity > b.intensity) ? a : b); } else { return(new Void()); } }
public void SetWinnerBetween(ChemicalElementEntity main, ChemicalElementEntity other, bool isMainWinning) { int couple = (int)(main.type | other.type); if (!this.winners.Exists(x => x.couple == couple)) { if (isMainWinning) { this.winners.Add(new IntToChemicalData(couple, main.type)); } else { this.winners.Add(new IntToChemicalData(couple, other.type)); } } else { Debug.LogWarning($"WARNING : This couple ({main} + {other}) is already registered ! Check it out for optimization !"); } }
public void SetMixOf(ChemicalElementEntity a, ChemicalElementEntity b, ChemicalElementEntity ent) { int couple = (int)(a.type | b.type); if (!this.couples.Exists(x => x.couple == couple)) { if (ent == null) { this.couples.Add(new IntToChemicalData(couple, ChemicalElement.Void, true)); } else { this.couples.Add(new IntToChemicalData(couple, ent.type)); } } else { Debug.LogWarning($"WARNING : This couple ({a} + {b}) is already registered ! Check it out for optimization !"); } }
public string GetMixOf(ChemicalElementEntity a, ChemicalElementEntity b) { int couple = (int)(a.type | b.type); IntToChemicalData data = this.couples.Find(x => x.couple == couple); if (data.couple > 0) { if (data.empty) { return(null); } this.stringBuilder.Clear(); this.stringBuilder.Append("Interactive.Engine.").Append(data.type.ToString()); return(this.stringBuilder.ToString()); } else { Debug.LogWarning($"WARNING : This couple ({a} + {b}) is not yet registered ! Check it out !"); return(voiddString); } }
// does elements in 'a' and 'b' validate this primary element composition protected internal bool CouldBeMadeOf(ChemicalElementEntity a, ChemicalElementEntity b) { ChemicalElement[] a1 = this.interactiveEngine.GetPrimariesOf(a); ChemicalElement[] a2 = this.interactiveEngine.GetPrimariesOf(b); bool found; foreach (ChemicalElement e in this.interactiveEngine.GetPrimariesOf(this)) { found = false; // search in first array foreach (ChemicalElement k in a1) { if (e == k) { found = true; break; } } // if not found in first array then if (!found) { // search in second array foreach (ChemicalElement k in a2) { if (e == k) { found = true; break; } } } // if not found in either one of them if (!found) { return(false); } } return(true); }
private bool IsStrongAgainst(ChemicalElementEntity other) { if (this.interactiveEngine.HasWinnerBetween(this, other)) { return(this.interactiveEngine.IsWinningAgainst(this, other)); } int mywin, hiswin; mywin = hiswin = 0; foreach (ChemicalElement w in this.interactiveEngine.GetPrimariesOf(this)) { foreach (ChemicalElement e in this.interactiveEngine.GetPrimariesOf(other)) { if (w == e) { hiswin++; } } } foreach (ChemicalElement w in this.interactiveEngine.GetPrimariesOf(other)) { foreach (ChemicalElement e in this.interactiveEngine.GetPrimariesOf(this)) { if (w == e) { mywin++; } } } bool isMainWinning = (mywin != hiswin && mywin > hiswin); this.interactiveEngine.SetWinnerBetween(this, other, isMainWinning); return(isMainWinning); }
public bool HasPrimariesOf(ChemicalElementEntity ent) => this.primaries.Exists(x => x.element == ent.type);
public bool HasWinnerBetween(ChemicalElementEntity main, ChemicalElementEntity other) { int couple = (int)(main.type | other.type); return(this.winners.Exists(x => x.couple == couple)); }
public void WarmUp() { this.ClearAll(); Type t; Type[] types; ChemicalElementEntity element; PhysicalInteractionEntity interaction; InteractiveStatus status; ChemicalElementEntity[] elements; ChemicalMaterialEntity[] materials; PhysicalStateEntity[] states; object[] parameters; t = typeof(ChemicalElementEntity); types = Assembly.GetAssembly(t).GetExportedTypes().Where(myType => myType.IsClass && !myType.IsAbstract && myType.IsSubclassOf(t)).ToArray(); parameters = new object[] { 0f }; elements = new ChemicalElementEntity[types.Length]; for (int i = 0; i < elements.Length; ++i) { elements[i] = Activator.CreateInstance(types[i], parameters) as ChemicalElementEntity; } t = typeof(ChemicalMaterialEntity); types = Assembly.GetAssembly(t).GetTypes().Where(myType => myType.IsClass && !myType.IsAbstract && myType.IsSubclassOf(t)).ToArray(); materials = new ChemicalMaterialEntity[types.Length]; for (int i = 0; i < materials.Length; ++i) { materials[i] = t.GetField(types[i].Name.ToLower()).GetValue(null) as ChemicalMaterialEntity; } t = typeof(PhysicalStateEntity); types = Assembly.GetAssembly(t).GetTypes().Where(myType => myType.IsClass && !myType.IsAbstract && myType.IsSubclassOf(t)).ToArray(); states = new PhysicalStateEntity[types.Length]; for (int i = 0; i < states.Length; ++i) { states[i] = t.GetField(types[i].Name.ToLower()).GetValue(null) as PhysicalStateEntity; } float start = Time.realtimeSinceStartup; // ELEMENT * ELEMENT for (int i = 0; i < elements.Length; ++i) { for (int j = i; j < elements.Length; ++j) { element = elements[i] * elements[j]; } } // ELEMENT * MATERIAL for (int i = 0; i < elements.Length; ++i) { for (int j = 0; j < materials.Length; ++j) { element = elements[i] * materials[j]; } } // ELEMENT * STATE for (int i = 0; i < elements.Length; ++i) { for (int j = 0; j < states.Length; ++j) { status = elements[i] * states[j]; } } // STATE * STATE for (int i = 0; i < states.Length; ++i) { for (int j = i; j < states.Length; ++j) { interaction = states[i] * states[j]; } } Debug.Log($"Took {Time.realtimeSinceStartup - start} seconds"); // INSPECTOR this.inspector_showDetails = new bool[this.primaries.Count]; }
protected void SetInteractiveState(ChemicalElementEntity e, ChemicalMaterialEntity m, PhysicalStateEntity p) { this.status.state = p; this.status.element = e; this.material = m; }
public bool HasWeaknessesOf(ChemicalElementEntity ent) { // only does that return(this.weaknesses.Exists(x => x.element == ent.type)); }
public InteractiveStatus(PhysicalStateEntity s, ChemicalElementEntity e) { this.state = s; this.element = e; }
private static ChemicalElementEntity Spawn(ChemicalElementEntity e) { // only does that return(Activator.CreateInstance(e.GetType(), ChemicalElementMixEntity.STANDARD_PARAMS) as ChemicalElementEntity); }
public void SetPrimariesOf(ChemicalElementEntity ent, ChemicalElement[] ps) { this.primaries.Add(new ChemicalToArrayData(ent.type, ps)); this.primaries.Sort(CompareChemicalToArrayData); }
public bool HasMixOf(ChemicalElementEntity a, ChemicalElementEntity b) { int couple = (int)(a.type | b.type); return(this.couples.Exists(x => x.couple == couple)); }