private void GetRaw()
{
Type[] types = ReflectionHelper.GetAllSubclasses <ModularBehaviour>();
if (_typeToggles == null)
{
_typeToggles = new TypeToggle[0];
}
for (int i = 0; i < types.Length; i++)
{
TypeToggle newToggle = new TypeToggle(types[i].Name, false);
bool flag = false;
foreach (TypeToggle t in _typeToggles)
{
flag = t.Equals(newToggle);
if (flag)
{
break;
}
}
if (!flag)
{
AddNew(types[i]);
}
}
//_typeToggles.Sort();
}
public void RemoveFromSelectedBehaviours(TypeToggle typeToggle)
{
List <TypeToggle> tempCollection = _selectedBehavs.ToList();
tempCollection.Remove(typeToggle);
typeToggle.SetToggle(false);
_selectedBehavs = tempCollection.ToArray();
}
public void AddToSelectedBehaviours(TypeToggle typeToggle)
{
List <TypeToggle> tempCollection = _selectedBehavs.ToList();
tempCollection.Add(typeToggle);
typeToggle.SetToggle(true);
_selectedBehavs = tempCollection.ToArray();
typeToggle.GetAllChildTypes();
}
protected virtual void DisplaySingleToggle(TypeToggle typeToggle)
{
string displayName =
(typeToggle.IsRaw ? RAW_PREFIX : COMPOSED_PREFIX) +
typeToggle.Name;
typeToggle.SetToggle(EditorGUILayout.Toggle(displayName,
typeToggle.Toggle));
}
public override bool Equals(object obj)
{
TypeToggle objAsToggle = (TypeToggle)obj;
if (obj == default)
{
return(false);
}
return(Name == objAsToggle.Name);
}
public bool SelectionContains(TypeToggle toggle)
{
for (int i = 0; i < _selectedBehavs.Length; i++)
{
if (toggle.Name == _selectedBehavs[i].Name)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Draws a single Type Toggle
/// </summary>
/// <param name="t"></param>
void DrawTypeFilter(TypeToggle t)
{
if (t == null)
{
return;
}
t.toggled = GUILayout.Toggle(t.toggled, t.type.Name);
if (t.toggled)
{
filterCount++;
}
}
private static IEnumerable <Type> GetAllTypesIn(ComposedBehavior composed)
{
for (int i = 0; i < composed.SelectedBehaviours.Length; i++)
{
TypeToggle toggle = composed.SelectedBehaviours[i];
Type[] profileTypes = toggle.GetAllChildTypes();
// Go through all the types
for (int j = 0; j < profileTypes.Length; j++)
{
yield return(profileTypes[j]);
}
}
}
protected override void DisplaySingleToggle(TypeToggle typeToggle)
{
bool added = _profile.SelectionContains(typeToggle);
string displayName =
(added ? "Remove :" : "Add :") +
typeToggle.Name;
if (GUILayout.Button(displayName))
{
if (added)
{
_profile.RemoveFromSelectedBehaviours(typeToggle);
}
else
{
_profile.AddToSelectedBehaviours(typeToggle);
}
}
}
/// <summary>
/// Will generate a behaviour tree to the given core using the limbs
/// and core's behaviours
/// </summary>
/// <param name="core">Target core</param>
public static void GenerateTree(Core core)
{
/*
* The tree works as follows:
*
* [X] - Random Selector
* [>] - Sequential Selector
*
* [>]Main Selector --> Layer 0
* / \
* [X]Attack Idle --> Layer 1
* Selector Leaf
* / | \
* [X]Shooter [X]Brawler [X]Tank --> Layer 2
* Selector Selector Selector
| | |
| ... ... ... --> Layer 3...
|
| - All the behaviours and composed behaviours will be added to the
| respective selector.
|
| - If a core has all limbs of its type it will be considered an elite
| and add the type special composed behaviour.
|
| - The Layer 2 Selector chances will be determined by taking into
| account the core type and limbs, the core having an weight of 0.8
| while limbs have 0.2 (Do not mix weights with influences. Influences
| were supposed to be the stats influence on the core, having nothing
| to do with the tree).
*/
BehaviourTree tree;
List <Type> addedTypes;
List <ComposedBehavior> composedBehaviors;
tree = core.gameObject.AddComponent <BehaviourTree>();
addedTypes = new List <Type>();
composedBehaviors = new List <ComposedBehavior>();
// Go through all the parts
foreach (ModulariuPartProfile p in core.GetLimbProfiles())
{
// Gather the required types
for (int i = 0; i < p.TypeToggles.Length; i++)
{
TypeToggle toggle = p.TypeToggles[i];
// Is it selected?
if (!toggle.Toggle)
{
continue;
}
Debug.Log("Adding: " + toggle.Name);
Type[] profileTypes = toggle.GetAllChildTypes();
// Go through all the types
for (int j = 0; j < profileTypes.Length; j++)
{
Type t = profileTypes[j];
// Add it if it was not already added
if (!addedTypes.Contains(t))
{
addedTypes.Add(t);
AddTypeToCore(t, core);
}
}
if (!toggle.IsRaw)
{
if (!composedBehaviors.Contains(toggle.ComposedBehavior))
{
composedBehaviors.Add(toggle.ComposedBehavior);
}
}
}
}
//TODO: Put bellow in another method
float shooterChance;
float brawlerChance;
float tankChance;
TreeSelector shooterSelector;
TreeSelector brawlerSelector;
TreeSelector tankSelector;
TreeSelector attackSelector;
ITreeComponent idleBehaviour;
TreeSelector mainSelector;
idleBehaviour = core.gameObject.AddComponent <IdleBehaviour>();
// Get the chances of each selector
shooterChance =
core.IsOfType(ModulariuType.Shooter) ?
0.8f :
0.1f;
brawlerChance =
core.IsOfType(ModulariuType.Brawler) ?
0.8f :
0.1f;
tankChance =
core.IsOfType(ModulariuType.Tank) ?
0.8f :
0.1f;
if (core.HasShooterLimb)
{
shooterChance += 0.2f * core.ShooterLimbs;
}
if (core.HasBrawlerLimb)
{
brawlerChance += 0.2f * core.BrawlerLimbs;
}
if (core.HasTankLimb)
{
tankChance += 0.2f * core.TankLimbs;
}
// Initialize selectors
shooterSelector = new TreeSelector(true, shooterChance);
brawlerSelector = new TreeSelector(true, brawlerChance);
tankSelector = new TreeSelector(true, tankChance);
attackSelector = new TreeSelector(true, 1,
shooterSelector, brawlerSelector, tankSelector);
mainSelector = new TreeSelector(false, 1, attackSelector, idleBehaviour);
// Set defaults and determine special abilities
//Is Shooter?
if (core.IsOfType(ModulariuType.Shooter))
{
// Is elite shooter
if (core.ShooterLimbs > 2)
{
shooterSelector
.AddNewOption(
CreateITreeComponentFromComposed(
core, _shooterSpecial));
}
shooterSelector
.AddNewOption(
CreateITreeComponentFromComposed(
core, _shooterDefault));
}
// Is Brawler?
else if (core.IsOfType(ModulariuType.Brawler))
{
// Is elite brawler
if (core.BrawlerLimbs > 2)
{
brawlerSelector
.AddNewOption(
CreateITreeComponentFromComposed(
core, _brawlerSpecial));
}
brawlerSelector
.AddNewOption(
CreateITreeComponentFromComposed(
core, _brawlerDefault));
}
// Is Tank?
else if (core.IsOfType(ModulariuType.Tank))
{
// Is elite tank
if (core.TankLimbs > 2)
{
tankSelector
.AddNewOption(
CreateITreeComponentFromComposed(
core, _tankSpecial));
}
tankSelector
.AddNewOption(
CreateITreeComponentFromComposed(
core, _tankDefault));
}
// Run through limb's behaviours and add them
foreach (ComposedBehavior c in composedBehaviors)
{
ITreeComponent component;
if (c.ComposedType == TreeComponentType.Selector)
{
component = CreateSelectorFromComposed(core, c);
}
else
{
component = CreateSequenceFromComposed(core, c);
}
switch (c.BehaviourType)
{
case ModulariuType.Shooter:
shooterSelector.AddNewOption(component);
break;
case ModulariuType.Brawler:
brawlerSelector.AddNewOption(component);
break;
case ModulariuType.Tank:
tankSelector.AddNewOption(component);
break;
}
}
// Initialize the tree with the default selector
tree.Initialize(mainSelector, true);
core.TreeCreationFinished();
}
