/// <summary>
/// Perofrms a sequential, cumulative combination of all states along an animation.
/// As an animation plays each state (keyframe) combines with the previous
/// to create a combined state. As the animation continues, these combined states
/// accumulate the changes of all states before them. Therefore, we need to pre-combine
/// the keyframes so that when animations are played they can properly interpolate.
///
/// </summary>
public void RefreshCombinedStates(ElementSave element, bool useDefaultAsStarting = true)
{
StateSave previous = null;
if (useDefaultAsStarting)
{
previous = element.DefaultState;
}
foreach (var animatedState in this.Keyframes.Where(item => !string.IsNullOrEmpty(item.StateName)))
{
var originalState = element.AllStates.FirstOrDefault(item => item.Name == animatedState.StateName);
if (originalState != null)
{
if (previous == null)
{
previous = originalState;
animatedState.CachedCumulativeState = originalState.Clone();
}
else
{
var combined = previous.Clone();
combined.MergeIntoThis(originalState);
combined.Name = originalState.Name;
animatedState.CachedCumulativeState = combined;
previous = combined;
}
}
}
foreach (var subAnimation in this.Keyframes.Where(item => !string.IsNullOrEmpty(item.AnimationName)))
{
InstanceSave instance = null;
string name = subAnimation.AnimationName;
if (name.Contains('.'))
{
int indexOfDot = name.IndexOf('.');
string instanceName = name.Substring(0, indexOfDot);
instance = element.Instances.FirstOrDefault(item => item.Name == instanceName);
}
if (instance == null)
{
subAnimation.SubAnimationViewModel.RefreshCombinedStates(element, false);
}
else
{
var instanceElement = Gum.Managers.ObjectFinder.Self.GetElementSave(instance);
if (instanceElement != null)
{
subAnimation.SubAnimationViewModel.RefreshCombinedStates(instanceElement, false);
}
}
}
}
private static void MoveState(TreeNode nodeMoving, TreeNode targetNode)
{
IElement currentElement = EditorLogic.CurrentElement;
StateSave toAdd = (StateSave)nodeMoving.Tag;
IElement sourceContainer = nodeMoving.GetContainingElementTreeNode().Tag as IElement;
IElement targetContainer = targetNode.GetContainingElementTreeNode().Tag as IElement;
if (targetNode.IsStateCategoryNode() || targetNode.IsStateListNode())
{
if (sourceContainer == targetContainer)
{
EditorLogic.CurrentElement.RemoveState(EditorLogic.CurrentStateSave);
}
else
{
toAdd = toAdd.Clone();
}
if (targetNode.IsStateCategoryNode())
{
((StateSaveCategory)targetNode.Tag).States.Add(toAdd);
}
else
{
targetContainer.States.Add(toAdd);
}
GlueCommands.Self.GenerateCodeCommands.GenerateElementCode(targetContainer);
GlueCommands.Self.RefreshCommands.RefreshUi(targetContainer);
}
}
private static void PastedCopiedState()
{
ElementSave container = SelectedState.Self.SelectedElement;
var targetCategory = SelectedState.Self.SelectedStateCategorySave;
/////////////////////Early Out//////////////////
if (container == null)
{
return;
}
//////////////////End Early Out////////////////
StateSave newStateSave = mCopiedState.Clone();
newStateSave.Variables.RemoveAll(item => item.CanOnlyBeSetInDefaultState);
newStateSave.ParentContainer = container;
string name = mCopiedState.Name + "Copy";
if (targetCategory != null)
{
name = StringFunctions.MakeStringUnique(name, targetCategory.States.Select(item => item.Name));
newStateSave.Name = name;
targetCategory.States.Add(newStateSave);
}
else
{
name = StringFunctions.MakeStringUnique(name, container.States.Select(item => item.Name));
newStateSave.Name = name;
container.States.Add(newStateSave);
}
StateTreeViewManager.Self.RefreshUI(container);
//SelectedState.Self.SelectedInstance = targetInstance;
SelectedState.Self.SelectedStateSave = newStateSave;
GumCommands.Self.FileCommands.TryAutoSaveElement(container);
}
private void PastedCopiedState()
{
ElementSave container = SelectedState.Self.SelectedElement;
/////////////////////Early Out//////////////////
if (container == null)
{
return;
}
//////////////////End Early Out////////////////
if (container.Categories.Count != 0)
{
MessageBox.Show("Pasting into elements with state categories may cause unexpected results. Please complain on codeplex!");
}
StateSave newStateSave = mCopiedState.Clone();
newStateSave.Variables.RemoveAll(item => item.CanOnlyBeSetInDefaultState);
newStateSave.ParentContainer = container;
string name = mCopiedState.Name + "Copy";
name = StringFunctions.MakeStringUnique(name, container.States.Select(item => item.Name));
newStateSave.Name = name;
container.States.Add(newStateSave);
StateTreeViewManager.Self.RefreshUI(container);
//SelectedState.Self.SelectedInstance = targetInstance;
SelectedState.Self.SelectedStateSave = newStateSave;
GumCommands.Self.FileCommands.TryAutoSaveElement(container);
}
private static bool AddAndModifyVariablesAccordingToDefault(ElementSave elementSave, StateSave defaultState)
{
bool wasModified = false;
// Use States and not AllStates because we want to make sure we
// have a default state.
if (elementSave.States.Count == 0 && defaultState != null)
{
StateSave stateToAdd = defaultState.Clone();
elementSave.States.Add(stateToAdd);
wasModified = true;
}
else if (elementSave.States.Count != 0 && defaultState != null)
{
// Replacing the default state:
// Update March 16, 2012
// Used to replace but realized
// it's better to not replace but
// instead add variables that are not
// already there. That way when the user
// switches types the old information isn't
// lost.
//elementSave.States[0] = replacement;
StateSave stateForNewType = defaultState.Clone();
foreach (VariableSave variableSave in stateForNewType.Variables)
{
VariableSave existingVariable = elementSave.DefaultState.GetVariableSave(variableSave.Name);
if (existingVariable == null)
{
wasModified = true;
elementSave.DefaultState.Variables.Add(variableSave.Clone());
}
else
{
// All of these properties are only relevant to the
// editor so we don't want to mark the object as modified
// when these properties are set.
existingVariable.Category = variableSave.Category;
#if !WINDOWS_8 && !UWP
existingVariable.CustomTypeConverter = variableSave.CustomTypeConverter;
#endif
existingVariable.ExcludedValuesForEnum.Clear();
existingVariable.ExcludedValuesForEnum.AddRange(variableSave.ExcludedValuesForEnum);
// let's fix any values that may be incorrectly set from types
if (existingVariable.Type == "float" && existingVariable.Value != null && (existingVariable.Value is float) == false)
{
float asFloat = 0.0f;
try
{
asFloat = (float)System.Convert.ChangeType(existingVariable.Value, typeof(float));
}
catch
{
// do nothing, we'll fall back to 0
}
existingVariable.Value = asFloat;
wasModified = true;
}
}
}
// We also need to add any VariableListSaves here
foreach (VariableListSave variableList in stateForNewType.VariableLists)
{
VariableListSave existingList = elementSave.DefaultState.GetVariableListSave(variableList.Name);
if (existingList == null)
{
wasModified = true;
// this type doesn't have this list yet, so let's add it
elementSave.DefaultState.VariableLists.Add(variableList.Clone());
}
else
{
// See the VariableSave section on why we don't set
// wasModified = true here
existingList.Category = variableList.Category;
}
}
foreach (var stateSaveCategory in elementSave.Categories)
{
VariableSave foundVariable = elementSave.DefaultState.Variables.FirstOrDefault(item => item.Name == stateSaveCategory.Name + "State");
if (foundVariable == null)
{
elementSave.DefaultState.Variables.Add(new VariableSave()
{
Name = stateSaveCategory.Name + "State",
Type = "string",
Value = null
#if GUM
,
CustomTypeConverter = new Gum.PropertyGridHelpers.Converters.AvailableStatesConverter(stateSaveCategory.Name)
#endif
});
}
else
{
#if GUM
foundVariable.CustomTypeConverter = new Gum.PropertyGridHelpers.Converters.AvailableStatesConverter(stateSaveCategory.Name);
#endif
}
}
VariableSaveSorter vss = new VariableSaveSorter();
vss.ListOrderToMatch = defaultState.Variables;
elementSave.DefaultState.Variables.Sort(vss);
}
else
{
// Let's give it an empty state so that it doesn't cause runtime problems
// Nevermind, this causes problelms in Gum, and it should be okay to pass a null state here
//elementSave.States.Add(new StateSave());
}
return(wasModified);
}
