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;
}
