void GenerateData(int size) { m_Data = new List <MyObjectType>(size); for (var i = 0; i < size; ++i) { var posX = Random.Range(0, 100); var posY = Random.Range(0, 100); string name; switch (i % 3) { case 0: name = $"Material {i}"; break; case 1: name = $"Mesh {i}"; break; case 3: name = $"Camera {i}"; break; default: name = $"Object {i}"; break; } var newObj = new MyObjectType { Id = i, Name = name, Position = new Vector2(posX, posY), Active = i % 2 == 0 }; m_Data.Add(newObj); } }
public void EquipItem(GameSettings gs, MyObjectType t) { switch (t) { case MyObjectType.mw: gs.playerProfile.mw_id.value = gs.ui_profile.mw_id.value; break; case MyObjectType.sw: gs.playerProfile.sw_id.value = gs.ui_profile.sw_id.value; break; case MyObjectType.mask: gs.playerProfile.mask_id.value = gs.ui_profile.mask_id.value; break; case MyObjectType.skill: break; case MyObjectType.outfit: gs.playerProfile.outfitID.value = gs.ui_profile.outfitID.value; break; default: break; } }
public static int GetPropC(this MyObjectType obj, int dfltVal) { if (obj != null && obj.PropertyA != null & obj.PropertyA.PropertyB != null) { return(obj.PropertyA.PropertyB.PropertyC); } return(dfltVal); }
public void init(AttackableComponent target, MyObjectType damageType, float speed = 21f, float damage = 1) { this.target = target; this.damageType = damageType; this.speed = speed; this.damage = damage; lineRenderer = GetComponent <LineRenderer>(); }
public MyObject CreateInstance(MyObjectType type) { Func <MyObject> factory; if (_store.TryGetValue(type, out factory)) { return(factory.Invoke()); } return(null); }
void CreateObject(Object obj, MyObjectType t) { GameObject go = Instantiate(slotTemplate) as GameObject; go.SetActive(true); go.transform.SetParent(gridParent); go.transform.localScale = Vector3.one; createdObjs.Add(go); UI.UI_Slot slot = go.GetComponent <UI_Slot>(); string targetText = null; bool isEquiped = false; isEquiped = gameSettings.isEquiped(obj, t); switch (t) { case MyObjectType.mw: Weapon mw = (Weapon)obj; targetText = mw.id.value; break; case MyObjectType.sw: Weapon sw = (Weapon)obj; targetText = sw.id.value; break; case MyObjectType.mask: Mask m = (Mask)obj; targetText = m.obj.id.value; break; case MyObjectType.skill: break; case MyObjectType.outfit: MeshContainer mc = (MeshContainer)obj; targetText = mc.id.value; break; default: break; } slot.type = type; slot.obj = obj; slot.item.text = targetText; slot.tick.SetActive(isEquiped); bool isBought = gameSettings.playerProfile.IsBought(targetText); slot.item.color = (isBought) ? Color.white : Color.gray; }
public void LoadObjects() { ClearCreatedObjs(); type = (MyObjectType)typeVariable.value; List <Object> objs = new List <Object>(); objs = gameSettings.r_manager.GetObjectListFromType(type); for (int i = 0; i < objs.Count; i++) { CreateObject(objs[i], type); } ui_slot_grid_size.ChangeSize(createdObjs.Count); }
public void Load() { if (fileType == FileType.JSON) { //SSL.LoadJSON(ref myObject,FileName, obfuscate); myObject = SSL.LoadJSON <MyObjectType>(FileName, obfuscate); } else { myObject = SSL.LoadXML <MyObjectType>(FileName, obfuscate); //SSL.LoadXML(ref myObject, FileName, obfuscate); } Apply(); spr.color = Color.blue; //physically show it was loaded output = SSL.LoadTXT(FileName); UpdateUI(); }
public List <Object> GetObjectListFromType(MyObjectType t) { List <Object> retVal = new List <Object>(); switch (t) { case MyObjectType.mw: List <Weapon> mw = GetAllWeaponsOfType(WeaponType.main); for (int i = 0; i < mw.Count; i++) { retVal.Add((Object)mw[i]); } break; case MyObjectType.sw: List <Weapon> sw = GetAllWeaponsOfType(WeaponType.sidearm); for (int i = 0; i < sw.Count; i++) { retVal.Add((Object)sw[i]); } break; case MyObjectType.mask: for (int i = 0; i < masks.Count; i++) { retVal.Add((Object)masks[i]); } break; case MyObjectType.skill: break; case MyObjectType.outfit: for (int i = 0; i < meshContainers.Count; i++) { retVal.Add((Object)meshContainers[i]); } break; default: break; } return(retVal); }
public bool isEquiped(Object obj, MyObjectType t) { bool retVal = false; switch (t) { case MyObjectType.mw: case MyObjectType.sw: Weapon w = (Weapon)obj; Weapon w_actual = r_manager.GetWeapon((t == MyObjectType.mw)? playerProfile.mw_id.value : playerProfile.sw_id.value); if (w == w_actual) { retVal = true; } break; case MyObjectType.mask: Mask m = (Mask)obj; Mask m_actual = r_manager.GetMask(playerProfile.mask_id.value); if (m == m_actual) { retVal = true; } break; case MyObjectType.skill: break; case MyObjectType.outfit: MeshContainer mc = (MeshContainer)obj; if (string.Equals(mc.id, playerProfile.outfitID.value)) { retVal = true; } break; default: break; } return(retVal); }
public void RemoveTargetInRange(AttackableComponent attackableComponent, MyObjectType targetObjectType) { AttackEffectiviness attackEffectiviness = GetEffectiviness(attackType, targetObjectType); switch (attackEffectiviness) { case AttackEffectiviness.Effective: effectiveTargets.Remove(attackableComponent); break; case AttackEffectiviness.Standard: standardTargets.Remove(attackableComponent); break; case AttackEffectiviness.Ineffective: ineffectiveTargets.Remove(attackableComponent); break; } }
static public float GetDamageModifier(MyObjectType attackType, MyObjectType defenceType) { AttackEffectiviness attackEffectiviness = GetEffectiviness(attackType, defenceType); switch (attackEffectiviness) { case AttackEffectiviness.Effective: return(2f); case AttackEffectiviness.Standard: return(1f); case AttackEffectiviness.Ineffective: return(0.5f); default: return(1f); } }
/// <summary> /// If you can’t use a registration lambda, you can add an activating event handler: /// </summary> public static void ActivatingEventHandler() { Console.WriteLine("\nPropertyandMethodInjection.ActivatingEventHandler:\n"); ContainerBuilder builder = new ContainerBuilder(); builder.RegisterType <TheDependency>(); builder .RegisterType <MyObjectType>() .OnActivating(e => { TheDependency dep = e.Context.Resolve <TheDependency>(); e.Instance.SetTheDependency(dep); }); IContainer container = builder.Build(); using (ILifetimeScope lifetimeScope = container.BeginLifetimeScope()) { MyObjectType instance = lifetimeScope.Resolve <MyObjectType>(); Console.WriteLine("instance.GetType(): " + instance.GetType()); } }
/// <summary> /// The simplest way to call a method to set a value on a component /// is to use a lambda expression component and handle the method /// call right in the activator: /// </summary> public static void MethodInjection() { Console.WriteLine("\nPropertyandMethodInjection.MethodInjection:\n"); ContainerBuilder builder = new ContainerBuilder(); builder.RegisterType <TheDependency>(); builder.Register(c => { MyObjectType myObjectType = new MyObjectType(); TheDependency dep = c.Resolve <TheDependency>(); myObjectType.SetTheDependency(dep); return(myObjectType); }); IContainer container = builder.Build(); using (ILifetimeScope lifetimeScope = container.BeginLifetimeScope()) { MyObjectType instance = lifetimeScope.Resolve <MyObjectType>(); Console.WriteLine("instance.GetType(): " + instance.GetType()); } }
static public AttackEffectiviness GetEffectiviness(MyObjectType attackType, MyObjectType defenceType) { if (attackType == MyObjectType.Light && defenceType == MyObjectType.Heavy) { return(AttackEffectiviness.Ineffective); } else if (attackType == MyObjectType.Heavy && defenceType == MyObjectType.Light) { return(AttackEffectiviness.Ineffective); } else if (attackType == MyObjectType.Light && defenceType == MyObjectType.Light) { return(AttackEffectiviness.Effective); } else if (attackType == MyObjectType.Heavy && defenceType == MyObjectType.Heavy) { return(AttackEffectiviness.Effective); } else { return(AttackEffectiviness.Standard); } }
public void AddTargetInRange(AttackableComponent attackableComponent, MyObjectType targetObjectType) { if (effectiveTargets.Contains(attackableComponent) || standardTargets.Contains(attackableComponent) || ineffectiveTargets.Contains(attackableComponent)) { return; } AttackEffectiviness attackEffectiviness = GetEffectiviness(attackType, targetObjectType); switch (attackEffectiviness) { case AttackEffectiviness.Effective: effectiveTargets.Add(attackableComponent); break; case AttackEffectiviness.Standard: standardTargets.Add(attackableComponent); break; case AttackEffectiviness.Ineffective: ineffectiveTargets.Add(attackableComponent); break; } }
public void EquipOrBuy(UI_Slot slot) { curSlot = slot; GameSettings s = Resources.Load("Game Settings") as GameSettings; string targetId = null; int targetCost = 0; switch (slot.type) { case MyObjectType.mw: case MyObjectType.sw: Weapon w = (Weapon)slot.obj; targetId = w.id.value; targetCost = w.price; break; case MyObjectType.mask: Mask m = (Mask)slot.obj; targetId = m.obj.id.value; targetCost = m.cost; break; case MyObjectType.skill: break; case MyObjectType.outfit: MeshContainer mc = (MeshContainer)slot.obj; targetId = mc.id.value; targetCost = mc.cost; break; default: break; } storeId = targetId; storeType = slot.type; VisualizeItem(s); bool isBought = s.playerProfile.IsBought(targetId); if (isBought) { isTrue.Invoke(); EquipItem(s, slot.type); } else { if (curCost > s.playerProfile.money.value) { //TODO: change color of buy button } curCost = targetCost; curCostVariable.value = targetCost.ToString(); isFalse.Invoke(); } onProfileUpdate.Raise(); }
public void ChangeType(int i) { type = (MyObjectType)i; }
protected MyObject(int age) { Type = MyObjectType.Age; Age = age; }
static float HandleDistFilter(MyObjectType myObj, Vector2 param) { var vec = myObj.Position - param; return(vec.magnitude); }
public void Register <T>(MyObjectType type) where T : MyObject, new() { this.Register(type, () => new T()); }
protected MyObject(object student) { Type = MyObjectType.Student; Student = student; }
public void Register(MyObjectType type, Func <MyObject> factory) { _store.Add(type, factory); }
protected MyObject(string name) { Type = MyObjectType.Name; Name = name; }