private void AppendPropSoloVerbs(VerbCollection pVerbCollection, vectorMscopethingsverbsSoloPropAnimVerb[] pVerbs)
{
if ((pVerbs == null) || (pVerbs.Length == 0))
{
return;
}
List <VerbSummaryItem> propSoloVerbs = new List <VerbSummaryItem>();
foreach (vectorMscopethingsverbsSoloPropAnimVerb verbDescriptor in pVerbs)
{
VerbSummaryItem verb = new VerbSummaryItem();
verb.VerbName = verbDescriptor.name;
verb.VerbType = "Prop Solo";
verb.ModelA = verbDescriptor.model;
verb.SetSortKey(verb.ModelA, verb.VerbName);
VerbSummaryItem oldItem = SearchEntry(propSoloVerbs, verb.SortKey);
if (oldItem == null)
{
propSoloVerbs.Add(verb);
}
else
{
oldItem.Iterations++;
}
}
pVerbCollection.PropSoloVerbs = propSoloVerbs.OrderBy(o => o.SortKey).ToList();
}
// ---------------------------------------------------------------------------------------------------------
public bool PopulateSummary(out string pErrorText, AddonPackageSource pSource = null)
{
pErrorText = null;
if (_initialized)
{
return(true);
}
if (!PopulateSummaryPreChecks(ref pSource, out pErrorText))
{
return(false);
}
bool isOk = true;
try
{
VerbCollection verbCollection = new VerbCollection();
verbCollection = CreateVerbsSummary(verbCollection, out pErrorText);
Verbs = CreateVerbsSummaryFromStateMachine(verbCollection);
}
catch (Exception exception)
{
pErrorText = $"VerbsSummary.PopulateSummary() EXCEPTION: {exception.Message}";
isOk = false;
}
_initialized = isOk;
return(isOk);
}
private void AppendPuppetSoloVerbs(VerbCollection pVerbCollection, vectorSoloVerb[] pVerbs)
{
if ((pVerbs == null) || (pVerbs.Length == 0))
{
return;
}
List <VerbSummaryItem> puppetSoloVerbs = new List <VerbSummaryItem>();
foreach (vectorSoloVerb verbDescriptor in pVerbs)
{
VerbSummaryItem verb = new VerbSummaryItem();
verb.VerbName = verbDescriptor.name;
verb.VerbType = "Puppet Solo";
verb.ModelA = verbDescriptor.model;
verb.SetSortKey(verb.ModelA, verb.VerbName);
VerbSummaryItem oldItem = SearchEntry(puppetSoloVerbs, verb.SortKey);
if (oldItem == null)
{
puppetSoloVerbs.Add(verb);
}
else
{
oldItem.Iterations++;
}
}
if (CompactDupVerbsByName)
{
puppetSoloVerbs = CompactVerbs(puppetSoloVerbs, CriteriumStringModelA, null);
}
pVerbCollection.PuppetSoloVerbs = puppetSoloVerbs.OrderBy(o => o.SortKey).ToList();
}
private VerbCollection CreateVerbsSummary(VerbCollection pVerbCollection, out string pErrorText)
{
pErrorText = null;
string verbsContents = null;
switch (AddonSource.SourceType)
{
case AddonPackageSourceType.Archiver:
verbsContents = AddonSource.Archiver.ExtractArchivedFileToString(VerbsFilename);
if (verbsContents == null)
{
if (!AddonSource.Archiver.FileExists(VerbsFilename))
{
return(pVerbCollection);
}
pErrorText = AddonSource.Archiver.LastErrorText;
return(pVerbCollection);
}
break;
case AddonPackageSourceType.Folder:
string verbsFile = Path.Combine(AddonSource.SourcePath, VerbsFilename);
if (!File.Exists(verbsFile))
{
return(pVerbCollection);
}
verbsContents = File.ReadAllText(verbsFile);
break;
}
if (verbsContents == null)
{
return(pVerbCollection);
}
Verbs verbsDescriptor = AssetFiles.Verbs.LoadFromString(verbsContents, out pErrorText);
if (verbsDescriptor == null)
{
return(pVerbCollection);
}
AppendPuppetSoloVerbs(pVerbCollection, verbsDescriptor.SoloVerb);
AppendPropSoloVerbs(pVerbCollection, verbsDescriptor.mscopethingsverbsSoloPropAnimVerb);
AppendHeldVerbs(pVerbCollection, verbsDescriptor.HeldPropVerb);
AppendInteractivePropVerbs(pVerbCollection, verbsDescriptor.PropVerb);
AppendPuppetMutualVerbs(pVerbCollection, verbsDescriptor.MutualVerb, verbsDescriptor.MutualStemVerb);
return(pVerbCollection);
}
private void AppendHeldVerbs(VerbCollection pVerbCollection, vectorHeldPropVerb[] pVerbs)
{
if ((pVerbs == null) || (pVerbs.Length == 0))
{
return;
}
List <VerbSummaryItem> heldPropsVerbs = new List <VerbSummaryItem>();
foreach (vectorHeldPropVerb verbDescriptor in pVerbs)
{
VerbSummaryItem verb = new VerbSummaryItem();
int elementCount = verbDescriptor.ItemsElementName.Length;
for (int index = 0; index < elementCount; ++index)
{
string value = verbDescriptor.Items[index];
switch (verbDescriptor.ItemsElementName[index])
{
case ItemsChoiceType.name: verb.VerbName = value; break;
case ItemsChoiceType.modelA: verb.ModelA = value; break;
case ItemsChoiceType.modelB: verb.ModelB = value; break;
}
}
verb.VerbType = "Held Prop";
verb.SetSortKey(verb.ModelB, verb.ModelA, verb.VerbName);
VerbSummaryItem oldItem = SearchEntry(heldPropsVerbs, verb.SortKey);
if (oldItem == null)
{
heldPropsVerbs.Add(verb);
}
else
{
oldItem.Iterations++;
}
}
if (CompactDupVerbsByName)
{
heldPropsVerbs = CompactVerbs(heldPropsVerbs, CriteriumStringModelB, CriteriumStringModelA);
}
pVerbCollection.HeldPropsVerbs = heldPropsVerbs.OrderBy(o => o.SortKey).ToList();
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
private VerbCollection CreateVerbsSummaryFromStateMachine(VerbCollection pVerbCollection)
{
string stateMachineFilePath;
string stateMachineContents = null;
switch (AddonSource.SourceType)
{
case AddonPackageSourceType.Archiver:
stateMachineFilePath = StateMachineFilename;
stateMachineContents = AddonSource.Archiver.ExtractArchivedFileToString(stateMachineFilePath);
if (stateMachineContents == null)
{
return(pVerbCollection);
}
break;
case AddonPackageSourceType.Folder:
stateMachineFilePath = Path.Combine(AddonSource.SourcePath, StateMachineFilename);
if (!File.Exists(stateMachineFilePath))
{
return(pVerbCollection);
}
stateMachineContents = File.ReadAllText(stateMachineFilePath);
break;
}
if (string.IsNullOrEmpty(stateMachineContents))
{
return(pVerbCollection);
}
string errorText;
StateMachine stateMachine = StateMachine.LoadFromString(stateMachineContents, out errorText);
if (stateMachine == null)
{
return(pVerbCollection);
}
const string gaitPrefix = "gaits/";
int gaitPrefixLen = gaitPrefix.Length;
const string gesturePrefix = "gestures/";
int gesturePrefixLen = gesturePrefix.Length;
List <Tuple <string, string> > animationFiles = null;
List <VerbSummaryItem> gaits = null;
List <VerbSummaryItem> gestures = null;
foreach (StateMachineNameMap nameMap in stateMachine.NameMap)
{
if (nameMap.Items == null)
{
continue;
}
foreach (object item in nameMap.Items)
{
Type transitionType = item.GetType();
if (transitionType == typeof(StateMachineNameMapState))
{
break;
}
if (transitionType == typeof(StateMachineNameMapAnimTransition))
{
StateMachineNameMapAnimTransition transition = (StateMachineNameMapAnimTransition)item;
VerbSummaryItem gaitAnimation = new VerbSummaryItem();
string animationFilepath = null;
for (int index = 0; index < transition.ItemsElementName.Length; ++index)
{
switch (transition.ItemsElementName[index])
{
case TransitionsItemsChoiceType.menuPath: gaitAnimation.VerbName = (string)transition.Items[index]; break;
case TransitionsItemsChoiceType.name: animationFilepath = ((string)transition.Items[index])?.ToLower(); break;
}
}
if ((gaitAnimation.VerbName?.ToLower() ?? "").StartsWith(gaitPrefix))
{
gaitAnimation.VerbName = gaitAnimation.VerbName?.Remove(0, gaitPrefixLen);
gaitAnimation.VerbType = "Gait Animation";
if (animationFiles == null)
{
animationFiles = GetAnimationFiles();
}
gaitAnimation.ModelA = GetAnimationPuppetModel(animationFilepath, animationFiles);
gaitAnimation.SetSortKey(gaitAnimation.ModelA, gaitAnimation.VerbName);
if (gaits == null)
{
gaits = new List <VerbSummaryItem>();
}
VerbSummaryItem oldItem = SearchEntry(gaits, gaitAnimation.SortKey);
if (oldItem == null)
{
gaits.Add(gaitAnimation);
}
else
{
oldItem.Iterations++;
}
}
continue;
}
if (transitionType == typeof(StateMachineNameMapGestureTransition))
{
StateMachineNameMapGestureTransition transition = (StateMachineNameMapGestureTransition)item;
string name = transition.menuPath;
if ((transition.menuPath?.ToLower() ?? "").StartsWith(gesturePrefix))
{
name = name.Remove(0, gesturePrefixLen);
}
VerbSummaryItem gestureAnimation = new VerbSummaryItem()
{
VerbName = name,
VerbType = "Gesture Animation"
};
string animationFilepath = transition.name;
if (animationFiles == null)
{
animationFiles = GetAnimationFiles();
}
gestureAnimation.ModelA = GetAnimationPuppetModel(animationFilepath, animationFiles);
gestureAnimation.SetSortKey(gestureAnimation.ModelA, gestureAnimation.VerbName);
if (gestures == null)
{
gestures = new List <VerbSummaryItem>();
}
VerbSummaryItem oldItem = SearchEntry(gestures, gestureAnimation.SortKey);
if (oldItem == null)
{
gestures.Add(gestureAnimation);
}
else
{
oldItem.Iterations++;
}
}
}
}
if (CompactDupVerbsByName)
{
gaits = CompactVerbs(gaits, CriteriumStringModelA, null);
gestures = CompactVerbs(gestures, CriteriumStringModelA, null);
}
if (gaits != null)
{
pVerbCollection.Gaits = gaits.OrderBy(o => o.SortKey).ToList();
}
if (gestures != null)
{
pVerbCollection.Gestures = gestures.OrderBy(o => o.SortKey).ToList();
}
return(pVerbCollection);
}
private void AppendPuppetMutualVerbs(VerbCollection pVerbCollection, vectorMutualVerb[] pVerbs, vectorMutualStemVerb[] pStemVerbs)
{
bool anyMutualVerb = (pVerbs != null) && (pVerbs.Length > 0);
bool anyMutualStemVerb = ((pStemVerbs != null) && (pStemVerbs.Length > 0));
if (!anyMutualVerb && !anyMutualStemVerb)
{
return;
}
List <VerbSummaryItem> puppetMutualVerbs = null;
if (anyMutualVerb)
{
puppetMutualVerbs = new List <VerbSummaryItem>();
foreach (vectorMutualVerb verbDescriptor in pVerbs)
{
VerbSummaryItem verb = new VerbSummaryItem();
verb.VerbName = verbDescriptor.name;
verb.VerbType = "Puppets Interaction";
verb.ModelA = verbDescriptor.modelA;
verb.ModelB = verbDescriptor.modelB;
verb.SetSortKey(verb.ModelA, verb.ModelB, verb.VerbName);
VerbSummaryItem oldItem = SearchEntry(puppetMutualVerbs, verb.SortKey);
if (oldItem == null)
{
puppetMutualVerbs.Add(verb);
}
else
{
oldItem.Iterations++;
}
}
}
if (anyMutualStemVerb)
{
if (puppetMutualVerbs == null)
{
puppetMutualVerbs = new List <VerbSummaryItem>();
}
foreach (vectorMutualStemVerb verbDescriptor in pStemVerbs)
{
VerbSummaryItem verb = new VerbSummaryItem();
verb.VerbName = verbDescriptor.name;
verb.VerbType = "Puppets Interaction";
verb.SetSortKey(null, null, verb.VerbName);
VerbSummaryItem oldItem = SearchEntry(puppetMutualVerbs, verb.SortKey);
if (oldItem == null)
{
puppetMutualVerbs.Add(verb);
}
else
{
oldItem.Iterations++;
}
}
}
if (CompactDupVerbsByName)
{
puppetMutualVerbs = CompactVerbs(puppetMutualVerbs, CriteriumStringModelA, CriteriumStringModelB);
}
pVerbCollection.PuppetMutualVerbs = puppetMutualVerbs.OrderBy(o => o.SortKey).ToList();
}
