public static StateSave GetStateThatVariableBelongsTo(CustomVariable variable, IElement element)
{
// We only loop through categories, not uncategorized States because a variable can't belong to an uncategorized state.
// See update below for-loop
foreach (StateSaveCategory category in element.StateCategoryList)
{
if (!category.SharesVariablesWithOtherCategories)
{
// This doesn't share variables, so it may own the variable
foreach (StateSave stateSave in category.States)
{
if (stateSave.AssignsVariable(variable))
{
return(stateSave);
}
}
}
}
// Update November 16, 2011
// Yes variables can actually
// belong to the no-category category
foreach (StateSave stateSave in element.States)
{
if (stateSave.AssignsVariable(variable))
{
return(stateSave);
}
}
return(null);
}
private void CreateContainerEntitySave()
{
mEntitySaveInstance = new NamedObjectSave();
mEntitySaveInstance.InstanceName = "StateEntityInstance";
mEntitySaveInstance.SourceType = SourceType.Entity;
mEntitySaveInstance.SourceClassType = mEntitySave.Name;
mDerivedSaveInstance = new NamedObjectSave();
mDerivedSaveInstance.InstanceName = "StateDerivedEntityInstance";
mDerivedSaveInstance.SourceType = SourceType.Entity;
mDerivedSaveInstance.SourceClassType = mDerivedEntitySave.Name;
mContainerEntitySave = new EntitySave();
mContainerEntitySave.Name = "StateEntityContainer";
mContainerEntitySave.NamedObjects.Add(mEntitySaveInstance);
mContainerEntitySave.NamedObjects.Add(mDerivedSaveInstance);
mTunneledUncategorizedStateInContainer = new CustomVariable();
mTunneledUncategorizedStateInContainer.Name = "TunneledUncategorizedStateVariable";
mTunneledUncategorizedStateInContainer.SourceObject = mEntitySaveInstance.InstanceName;
mTunneledUncategorizedStateInContainer.SourceObjectProperty = mRenamedExposedUncategorizedStateVariable.Name;
mContainerEntitySave.CustomVariables.Add(mTunneledUncategorizedStateInContainer);
ObjectFinder.Self.GlueProject.Entities.Add(mContainerEntitySave);
}
void OnPropertyValueChanged(object s, PropertyValueChangedEventArgs e)
{
string propertyName = e.ChangedItem.Label;
CustomVariable customVariable = null;
if (mCurrentNos.SourceType == SourceType.Entity && !string.IsNullOrEmpty(mCurrentNos.SourceClassType))
{
IElement entitySave = ObjectFinder.Self.GetIElement(mCurrentNos.SourceClassType);
customVariable = entitySave.GetCustomVariable(propertyName).Clone();
}
else
{
customVariable = new CustomVariable();
customVariable.Name = propertyName;
}
customVariable.DefaultValue = e.ChangedItem.Value;
customVariable.Type = mCurrentNos.GetCustomVariable(propertyName).Type;
mCurrentElementRuntime.SetCustomVariable(customVariable);
if (mRuntimeOptions.ShouldSave)
{
GlueViewCommands.Self.GlueProjectSaveCommands.SaveGlux();
}
}
public static bool ShouldGenerateEventsForVariable(CustomVariable customVariable, IElement container)
{
// Victor Chelaru
// August 17, 2013
// I debated whether
// static variables should
// create events or not. They
// technically could, but that means
// that the custom code events would have
// to be modified when switching between static
// and instance. This could have some impacts on
// GlueView code parsing, and it currently seems to
// be something that is either rare or something which
// has some pretty simple workarounds. Therefore, I'm going
// to say that only instance variables can create events.
bool shouldGenerate = customVariable.CreatesEvent && !customVariable.IsShared;
if (shouldGenerate && customVariable.DefinedByBase)
{
var baseContainers = ObjectFinder.Self.GetAllBaseElementsRecursively(container);
foreach (var baseContainer in baseContainers)
{
if (baseContainer.CustomVariables.Any(item => item.DefinedByBase == false && item.Name == customVariable.Name && item.CreatesEvent))
{
shouldGenerate = false;
break;
}
}
}
return(shouldGenerate);
}
public void CustomVariable_Constructor_Sets_Properties()
{
var customVariable = new CustomVariable("name", "value");
Assert.AreEqual("name", customVariable.Name);
Assert.AreEqual("value", customVariable.Value);
}
private static void MoveStateCategory(TreeNode nodeMoving, TreeNode targetNode)
{
if (targetNode.IsRootCustomVariablesNode() || targetNode.IsCustomVariable())
{
// The user drag+dropped a state category into the variables
// Let's make sure that it's all in the same Element though:
if (targetNode.GetContainingElementTreeNode() == nodeMoving.GetContainingElementTreeNode())
{
StateSaveCategory category = nodeMoving.Tag as StateSaveCategory;
// expose a variable that exposes the category
CustomVariable customVariable = new CustomVariable();
if (category.SharesVariablesWithOtherCategories)
{
customVariable.Type = "VariableState";
customVariable.Name = "CurrentState";
}
else
{
customVariable.Type = category.Name;
customVariable.Name = "Current" + category.Name + "State";
}
IElement element = targetNode.GetContainingElementTreeNode().Tag as IElement;
element.CustomVariables.Add(customVariable);
GlueCommands.Self.GenerateCodeCommands.GenerateCurrentElementCode();
EditorLogic.CurrentElementTreeNode.UpdateReferencedTreeNodes();
}
}
}
internal bool ApplyTo(EntitySave entity)
{
bool createdNewVariable = false;
entity.Properties.SetValue(nameof(IsNetworkEntity), IsNetworkEntity);
foreach (var variableVm in this.VariableList)
{
var matchingVariable = entity.GetCustomVariable(variableVm.Name);
var isNetworkEntity = variableVm.IsChecked;
// The network screen will show additional variables that may not be exposed as
// variables in Glue, like velocity. In this case the user may enable these without
// actually having variables. We'll add them...hopefully that doesn't cause problems...
if (isNetworkEntity && matchingVariable == null)
{
matchingVariable = new CustomVariable
{
Name = variableVm.Name,
Type = "float", // do we always assume this? It is the case for all PositionedObject values
};
createdNewVariable = true;
entity.CustomVariables.Add(matchingVariable);
}
if (matchingVariable != null)
{
matchingVariable.Properties.SetValue(IsNetworkVariableProperty, isNetworkEntity);
}
}
return(createdNewVariable);
}
public void UrchinUriBuilder_GetFinalCustomVariables_Selects_Correct_Final_Variables()
{
var analyticsClient = new UrchinAnalyticsClient();
analyticsClient.SessionCustomVariables[0] = new CustomVariable("session-one-name", "session-one-value");
analyticsClient.SessionCustomVariables[2] = new CustomVariable("session-three-name", "session-three-value");
analyticsClient.VisitorCustomVariables[0] = new CustomVariable("Visitor-one-name", "Visitor-one-value");
analyticsClient.VisitorCustomVariables[1] = new CustomVariable("Visitor-two-name", "Visitor-two-value");
var activityScopedVariables = new CustomVariableSlots();
activityScopedVariables[0] = new CustomVariable("activity-one-name", "activity-one-value");
activityScopedVariables[1] = new CustomVariable("activity-two-name", "activity-two-value");
activityScopedVariables[3] = new CustomVariable("activity-four-name", "activity-four-value");
var final = analyticsClient.GetFinalCustomVariables(activityScopedVariables).ToDictionary(s => s.Slot);
Assert.AreEqual(CustomVariableScope.Visitor, final[0].Scope);
Assert.AreEqual(CustomVariableScope.Visitor, final[1].Scope);
Assert.AreEqual(CustomVariableScope.Session, final[2].Scope);
Assert.AreEqual(CustomVariableScope.Activity, final[3].Scope);
Assert.AreEqual("Visitor-one-name", final[0].Variable.Name);
Assert.AreEqual("Visitor-two-name", final[1].Variable.Name);
Assert.AreEqual("session-three-name", final[2].Variable.Name);
Assert.AreEqual("activity-four-name", final[3].Variable.Name);
}
private void CreateContainerEntitySave()
{
mContainerEntitySave = new EntitySave();
mContainerEntitySave.Name = "ContainerCustomVariableEntity";
mBaseNosInContainer = new NamedObjectSave();
mBaseNosInContainer.InstanceName = mEntitySave.Name + "Instance";
mBaseNosInContainer.SourceType = SourceType.Entity;
mBaseNosInContainer.SourceClassType = mEntitySave.Name;
mContainerEntitySave.NamedObjects.Add(mBaseNosInContainer);
CustomVariable customVariable = new CustomVariable();
customVariable.Name = "TunneledCategorizedStateVariable";
customVariable.SourceObject = mBaseNosInContainer.InstanceName;
customVariable.SourceObjectProperty = "CurrentStateCategoryState";
customVariable.Type = "StateCategory";
mContainerEntitySave.CustomVariables.Add(customVariable);
mDerivedNosInContainer = new NamedObjectSave();
mDerivedNosInContainer.InstanceName = "DerivedNosInContainer";
mDerivedNosInContainer.SourceType = SourceType.Entity;
mDerivedNosInContainer.SourceClassType = mDerivedEntitySave.Name;
mDerivedNosInContainer.UpdateCustomProperties();
mContainerEntitySave.NamedObjects.Add(mDerivedNosInContainer);
ObjectFinder.Self.GlueProject.Entities.Add(mContainerEntitySave);
}
private void CreateEntitySaves()
{
mEntitySave = new EntitySave();
mEntitySave.Name = "StateTestEntity";
ObjectFinder.Self.GlueProject.Entities.Add(mEntitySave);
CreateNamedObjectWithSetVariable();
CreateEntityVariables();
CreateEntitySaveState();
mContainer = new EntitySave();
mContainer.Name = "StateTestContainerEntity";
NamedObjectSave nos = new NamedObjectSave();
nos.InstanceName = mEntitySave.Name + "Instance";
nos.SourceType = SourceType.Entity;
nos.SourceClassType = mEntitySave.Name;
mContainer.NamedObjects.Add(nos);
CustomVariable stateTunnel = new CustomVariable();
stateTunnel.SourceObject = nos.InstanceName;
stateTunnel.SourceObjectProperty = "CurrentState";
stateTunnel.Type = "VariableState";
stateTunnel.Name = "StateTunnelVariable";
mContainer.CustomVariables.Add(stateTunnel);
CreateContainerEntityState();
}
public static IElement GetElementIfCustomVariableIsVariableState(CustomVariable customVariable, IElement saveObject)
{
if (customVariable.GetIsVariableState() && string.IsNullOrEmpty(customVariable.SourceObject))
{
return(saveObject);
}
else
{
NamedObjectSave sourceNamedObjectSave = saveObject.GetNamedObjectRecursively(customVariable.SourceObject);
if (sourceNamedObjectSave != null)
{
EntitySave sourceEntitySave = ObjectFinder.Self.GetEntitySave(sourceNamedObjectSave.SourceClassType);
if (sourceEntitySave != null &&
((sourceEntitySave.States.Count != 0 && customVariable.SourceObjectProperty == "CurrentState") ||
sourceEntitySave.StateCategoryList.ContainsCategoryName(customVariable.Type))
)
{
return(sourceEntitySave);
}
else if (sourceEntitySave == null)
{
ScreenSave sourceScreenSave = ObjectFinder.Self.GetScreenSave(sourceNamedObjectSave.SourceClassType);
if (sourceScreenSave != null && sourceScreenSave.States.Count != 0 && customVariable.SourceObjectProperty == "CurrentState")
{
return(sourceScreenSave);
}
}
}
return(null);
}
}
private void CreateEntitySave()
{
mEntitySave = ExposedVariableTests.CreateEntitySaveWithStates("CustomVariableEntity");
mExposedStateInCategoryVariable = new CustomVariable();
mExposedStateInCategoryVariable.Name = "CurrentStateCategoryState";
mExposedStateInCategoryVariable.Type = "StateCategory";
mExposedStateInCategoryVariable.SetByDerived = true;
mEntitySave.CustomVariables.Add(mExposedStateInCategoryVariable);
mSetByDerivedVariable = new CustomVariable();
mSetByDerivedVariable.Type = "float";
mSetByDerivedVariable.Name = "SomeVariable";
mSetByDerivedVariable.SetByDerived = true;
mEntitySave.CustomVariables.Add(mSetByDerivedVariable);
mTextInBase = new NamedObjectSave();
mTextInBase.InstanceName = "TextObject";
mTextInBase.SourceType = SourceType.FlatRedBallType;
mTextInBase.SourceClassType = "Text";
mEntitySave.NamedObjects.Add(mTextInBase);
CustomVariable customVariable = new CustomVariable();
customVariable.Name = "TunneledDisplayText";
customVariable.SourceObject = mTextInBase.InstanceName;
customVariable.SourceObjectProperty = "DisplayText";
customVariable.Type = "string";
customVariable.OverridingPropertyType = "int";
mEntitySave.CustomVariables.Add(customVariable);
ObjectFinder.Self.GlueProject.Entities.Add(mEntitySave);
}
private TreeNode FindCustomVariableInEntities(CustomVariable variable, TreeNodeCollection nodeCollection)
{
TreeNode foundNode = null;
foreach (TreeNode treeNode in nodeCollection)
{
if (treeNode is EntityTreeNode)
{
foundNode = ((EntityTreeNode)treeNode).GetTreeNodeFor(variable);
if (foundNode != null)
{
break;
}
}
else
{
foundNode = FindCustomVariableInEntities(variable, treeNode.Nodes);
if (foundNode != null)
{
break;
}
}
}
return(foundNode);
}
private object Convert(object whatToConvert, CustomVariable variable)
{
// early out:
if (whatToConvert == null)
{
return(null);
}
switch (variable.Type)
{
case "float":
return(System.Convert.ToSingle(whatToConvert.ToString(), CultureInfo.InvariantCulture));
case "int":
return(System.Convert.ToInt32(whatToConvert.ToString()));
case "bool":
return(System.Convert.ToBoolean(whatToConvert.ToString()));
case "long":
return(System.Convert.ToInt64(whatToConvert.ToString()));
case "double":
return(System.Convert.ToDouble(whatToConvert.ToString(), CultureInfo.InvariantCulture));
case "byte":
return(System.Convert.ToByte(whatToConvert.ToString()));
default:
return(whatToConvert);
}
}
internal void PopulateWithReferencesTo(CustomVariable customVariable, IElement container)
{
foreach (var state in container.AllStates)
{
if (state.InstructionSaves.Any(instruction => instruction.Member == customVariable.Name))
{
listBox1.Items.Add(state);
}
}
var derivedElements = ObjectFinder.Self.GetAllElementsThatInheritFrom(container);
foreach (var element in derivedElements)
{
foreach (var variable in element.CustomVariables.Where(item => item.DefinedByBase && item.Name == customVariable.Name))
{
listBox1.Items.Add(variable);
}
}
foreach (var ers in container.GetEventsOnVariable(customVariable.Name))
{
listBox1.Items.Add(ers);
}
}
public void TestRegularVisibility()
{
CustomVariable visibleVariable = mEntitySave.GetCustomVariable("Visible");
mElementRuntime.SetCustomVariable(visibleVariable, mElementRuntime.AssociatedIElement, false, false);
ElementRuntime containedElementRuntime = mElementRuntime.ContainedElements[0] as ElementRuntime;
Sprite sprite = containedElementRuntime.DirectObjectReference as Sprite;
if (sprite.AbsoluteVisible)
{
throw new Exception("Sprite is visible, but it is part of an element runtime that isn't, so it shouldn't be");
}
sprite.Visible = false;
mElementRuntime.SetCustomVariable(visibleVariable, mElementRuntime.AssociatedIElement, true, false);
if (sprite.Visible)
{
throw new Exception("The Sprite should still have a relative Visibility of true, even though the parent is false");
}
sprite.Visible = true;
if (!sprite.AbsoluteVisible)
{
throw new Exception("The Sprite should be visible now!");
}
}
public AvailableStates(NamedObjectSave currentNamedObject, IElement currentElement, CustomVariable currentCustomVariable, StateSave currentStateSave) : base()
{
CurrentNamedObject = currentNamedObject;
CurrentElement = currentElement;
CurrentCustomVariable = currentCustomVariable;
CurrentStateSave = currentStateSave;
}
public static void RemoveCustomVariable(CustomVariable customVariable, List <string> additionalFilesToRemove)
{
// additionalFilesToRemove is added to keep this consistent with other remove methods
IElement element = ObjectFinder.Self.GetElementContaining(customVariable);
if (element == null || !element.CustomVariables.Contains(customVariable))
{
throw new ArgumentException();
}
else
{
element.CustomVariables.Remove(customVariable);
element.RefreshStatesToCustomVariables();
List <EventResponseSave> eventsReferencedByVariable = element.GetEventsOnVariable(customVariable.Name);
foreach (EventResponseSave ers in eventsReferencedByVariable)
{
element.Events.Remove(ers);
}
}
UpdateCurrentTreeNodeAndCodeAndSave();
UpdateAllDerivedElementFromBaseValues(true);
PluginManager.ReactToVariableRemoved(customVariable);
}
private void HandleScopeSet(CustomVariable customVariable, object oldValue)
{
var owner = GlueState.Self.CurrentElement;
var newScope = customVariable.Scope;
SetDerivedElementVariables(owner, customVariable.Name, newScope);
}
public static void SetDefaultValueFor(CustomVariable customVariable, IElement element)
{
object defaultValue = GetDefaultValueFor(customVariable, element);
if(defaultValue != null)
{
customVariable.DefaultValue = defaultValue;
}
}
public AvailableAnimationChainsStringConverter(CustomVariable customVariable, StateSave stateSave = null)
{
IElement element = ObjectFinder.Self.GetVariableContainer(customVariable);
NamedObjectSave referencedNos = element.GetNamedObjectRecursively(customVariable.SourceObject);
Initialize(element, referencedNos, stateSave);
}
public void TestRelativeAbsoluteConversion()
{
NamedObjectSave nos = new NamedObjectSave();
nos.SourceType = SourceType.FlatRedBallType;
nos.SourceClassType = "Sprite";
nos.UpdateCustomProperties();
nos.InstanceName = "SpriteObject";
nos.SetPropertyValue("ScaleX", 2.0f);
nos.SetPropertyValue("X", 4.0f);
nos.SetPropertyValue("RotationZ", 4.0f);
nos.SetPropertyValue("RotationZVelocity", 4.0f);
mEntitySave.NamedObjects.Add(nos);
CustomVariable customVariable = new CustomVariable();
customVariable.SourceObject = nos.InstanceName;
customVariable.SourceObjectProperty = "ScaleY";
customVariable.DefaultValue = 8.0f;
mEntitySave.CustomVariables.Add(customVariable);
ElementRuntime elementRuntime = new ElementRuntime();
elementRuntime.Initialize(mEntitySave, null, null, null, null);
Sprite sprite = elementRuntime.ContainedElements[0].DirectObjectReference as Sprite;
sprite.ForceUpdateDependencies();
if (elementRuntime.X != 0)
{
throw new Exception("NOS variables are being applied to the container instead of just to the NOS");
}
if (sprite.X != 4.0f)
{
throw new Exception("Absolute values should get set when setting X on objects even though they're attached");
}
if (sprite.RotationZ != 4.0f)
{
throw new Exception("Absolute values should get set when setting RotationZ on objects even though they're attached");
}
if (sprite.RelativeRotationZVelocity != 4.0f)
{
throw new Exception("Setting RotationZVelocity should set RelativeRotationZVelocity");
}
if (sprite.ScaleX != 2.0f)
{
throw new Exception("Scale values aren't properly showing up on Sprites");
}
if (sprite.ScaleY != 8.0f)
{
throw new Exception("Scale values aren't properly showing up on Sprites");
}
}
public void ScopedCustomVariable_Constructor_Sets_Properties()
{
var customVariable = new CustomVariable("name3", "value3");
var scopedCustomVariableSlot = new ScopedCustomVariableSlot(CustomVariableScope.Session, customVariable, 3);
Assert.AreEqual(CustomVariableScope.Session, scopedCustomVariableSlot.Scope);
Assert.AreEqual(3, scopedCustomVariableSlot.Slot);
Assert.AreEqual(customVariable, scopedCustomVariableSlot.Variable);
}
public static void SetDefaultValueFor(CustomVariable customVariable, IElement element)
{
object defaultValue = GetDefaultValueFor(customVariable, element);
if (defaultValue != null)
{
customVariable.DefaultValue = defaultValue;
}
}
public void CustomVariableSlots_Indexer_Sets_Slot()
{
var slots = new CustomVariableSlots();
var slotOne = new CustomVariable("one", "1");
slots[1] = slotOne;
Assert.AreEqual(slotOne, slots[1]);
}
public void TestMethodCallParser()
{
CustomVariable variable = MethodCallParser.GetCustomVariableFromNosOrElement(mParentElementRuntime.ContainedElements[0], "CsvTypeVariable");
if (variable == null || variable.DefaultValue == null)
{
throw new Exception("The MethodCallParser is not properly finding values on NamedObjects");
}
}
public void Update(string containerName, CustomVariable customVariable)
{
var container = ObjectFinder.Self.GetIElement(containerName);
var currentNos = container.GetCustomVariableRecursively(customVariable.Name);
CopyObject(customVariable, currentNos);
RefreshElement(container);
//GlueCommand.GluxCommands.SaveGlux();
}
private static ICodeBlock AssignValuesUsingStartingValues(IElement element, ICodeBlock curBlock, Dictionary <InstructionSave, InterpolationCharacteristic> mInterpolationCharacteristics)
{
foreach (KeyValuePair <InstructionSave, InterpolationCharacteristic> kvp in mInterpolationCharacteristics)
{
if (kvp.Value != InterpolationCharacteristic.CantInterpolate)
{
curBlock = curBlock.If("set" + kvp.Key.Member);
CustomVariable variable = element.GetCustomVariable(kvp.Key.Member);
var nos = element.GetNamedObjectRecursively(variable.SourceObject);
if (nos != null)
{
NamedObjectSaveCodeGenerator.AddIfConditionalSymbolIfNecesssary(curBlock, nos);
}
string relativeValue = InstructionManager.GetRelativeForAbsolute(kvp.Key.Member);
string variableToAssign = kvp.Key.Member;
string leftSideOfEqualsWithRelative = GetLeftSideOfEquals(element, variable, kvp.Key, true);
if (!string.IsNullOrEmpty(leftSideOfEqualsWithRelative) && leftSideOfEqualsWithRelative != kvp.Key.Member)
{
string beforeDotParent = variable.SourceObject;
if (string.IsNullOrEmpty(variable.SourceObject))
{
beforeDotParent = "this";
}
curBlock = curBlock.If(beforeDotParent + ".Parent != null");
AddAssignmentForInterpolationForVariable(curBlock, variable, variableToAssign, leftSideOfEqualsWithRelative);
curBlock = curBlock.End().Else();
}
AddAssignmentForInterpolationForVariable(curBlock, variable, variableToAssign, variableToAssign);
if (!string.IsNullOrEmpty(relativeValue))
{
curBlock = curBlock.End(); // end the else
}
curBlock = curBlock.End();
if (nos != null)
{
NamedObjectSaveCodeGenerator.AddEndIfIfNecessary(curBlock, nos);
}
}
}
return(curBlock);
}
internal static void TryGenerateEventsForVariable(ICodeBlock codeBlock, CustomVariable customVariable, IElement container)
{
var shouldGenerate = ShouldGenerateEventsForVariable(customVariable, container);
// Currently we don't support events on static variables
if (shouldGenerate)
{
EventCodeGenerator.GenerateEventsForVariable(codeBlock, customVariable.Name);
}
}
private bool GetIfCanBeRenamed(CustomVariable customVariable)
{
if (customVariable.GetIsVariableState())
{
return(false);
}
return(true);
}
private TiledObjectTypePropertySave CreatePropertySaveFrom(CustomVariable variable)
{
var toReturn = new TiledObjectTypePropertySave();
toReturn.name = variable.Name;
toReturn.Type = GetTmxFriendlyType(variable.Type);
toReturn.DefaultAsString = GetTmxFriendlyValue(variable.DefaultValue?.ToString(), variable.Type);
return(toReturn);
}
public static InterpolationCharacteristic GetInterpolationCharacteristic(CustomVariable customVariable, IElement container)
{
string variableType = null;
if (customVariable != null)
{
if (!string.IsNullOrEmpty(customVariable.OverridingPropertyType))
{
variableType = customVariable.OverridingPropertyType;
}
else
{
variableType = customVariable.Type;
}
}
if (customVariable != null && customVariable.GetIsVariableState(container))
{
return InterpolationCharacteristic.CanInterpolate;
}
if (customVariable == null ||
variableType == null ||
variableType == "string" ||
variableType == "bool" ||
variableType == "Color" ||
customVariable.GetIsFile() ||
customVariable.GetIsCsv() ||
(customVariable.GetRuntimeType() != null && customVariable.GetRuntimeType().IsEnum)
)
{
return InterpolationCharacteristic.CantInterpolate;
}
string velocityMember = null;
if(!string.IsNullOrEmpty(customVariable.SourceObject))
{
velocityMember = FlatRedBall.Instructions.InstructionManager.GetVelocityForState(customVariable.SourceObjectProperty);
}
else
{
velocityMember = FlatRedBall.Instructions.InstructionManager.GetVelocityForState(customVariable.Name);
}
if (!string.IsNullOrEmpty(velocityMember))
{
// There's a velocity variable for this, but we need to make sure
// it's actually available
var exposableMembers = ExposedVariableManager.GetExposableMembersFor(container, false);
if (exposableMembers.Any(item=>item.Member ==velocityMember))
{
return InterpolationCharacteristic.CanInterpolate;
}
}
// December 26, 2013
// This used to not pass
// a value for maxDepth which
// means a maxDepth of 0. Not
// sure why, but we do want to look
// at tunneling at any depth.
int maxDepth = int.MaxValue;
if(customVariable.HasAccompanyingVelocityConsideringTunneling(container, maxDepth) )
{
return InterpolationCharacteristic.CanInterpolate;
}
else
{
return InterpolationCharacteristic.NeedsVelocityVariable;
}
}
public static bool IsStateMissingFor(CustomVariable customVariable, IElement container)
{
// We can't use the CustomVariable's check because
// the state may not exist. Therefore we have to look
// at the properties and determine if it should be associated
// with a state.
bool isState = IsCustomVariableReferencingState(customVariable);
if (isState)
{
// This variable is an exposed state, so let's make sure the state exists for it
StateSaveCategory existingCategory = null;
if (customVariable.Type == "VariableState")
{
if (container.States.Count != 0)
{
return false;
}
else if (container.StateCategoryList.FirstOrDefault(category => category.SharesVariablesWithOtherCategories == true) != null)
{
return false;
}
else
{
return true;
}
}
else
{
bool returnValue = container.StateCategoryList.FirstOrDefault(
category =>
category.SharesVariablesWithOtherCategories == false &&
category.Name == customVariable.Type) == null;
return returnValue;
}
}
else
{
return false;
}
}
private static object GetDefaultValueFor(CustomVariable customVariable, IElement element)
{
object valueToReturn = null;
// Lets handle all file types here:
//if (customVariable.Type == "Texture2D")
if(customVariable.GetIsFile())
{
// If we don't return
// null then this will
// return the name of the
// file (like "redball.bmp").
// This will screw up code generation
// because texture variables can only be
// set to Texture2D instances, not to the
// name of the image.
valueToReturn = null;
}
else
{
try
{
if (!string.IsNullOrEmpty(customVariable.SourceObject) && !string.IsNullOrEmpty(customVariable.SourceObjectProperty))
{
NamedObjectSave nos = element.GetNamedObjectRecursively(customVariable.SourceObject);
if (nos != null)
{
object defaultValue = GetDefaultValueFor(nos, customVariable.SourceObjectProperty, customVariable.OverridingPropertyType);
valueToReturn = defaultValue;
}
}
else if (customVariable.Name == "Visible" && element is EntitySave && ((EntitySave)element).ImplementsIVisible)
{
// This shouldn't be true, we don't want to set the value
// because we don't want to kick off events
//valueToReturn = true;
valueToReturn = null;
}
else if (customVariable.Name == "Enabled" && element is EntitySave && ((EntitySave)element).ImplementsIWindow)
{
// This shouldn't be true, we don't want to set the value
// because we don't want to kick off events
//valueToReturn = true;
valueToReturn = null;
}
else
{
valueToReturn = GetDefaultValueForPropertyInType(customVariable.Name, "PositionedObject");
}
}
catch
{
// do nothing.
}
if (valueToReturn is Microsoft.Xna.Framework.Color)
{
string standardName =
AvailableColorTypeConverter.GetStandardColorNameFrom((Color)valueToReturn);
if (string.IsNullOrEmpty(standardName))
{
return "Red";
}
else
{
return standardName;
}
}
}
return valueToReturn;
}
private static bool IsCustomVariableReferencingState(CustomVariable customVariable)
{
bool toReturn = string.IsNullOrEmpty(customVariable.SourceObject) &&
TypeManager.GetTypeFromString(customVariable.Type) == null &&
!customVariable.GetIsCsv() &&
customVariable.Name.StartsWith("Current") &&
customVariable.Name.EndsWith("State");
return toReturn;
}
/// <summary>
///
/// </summary>
/// <param name="customVariable"></param>
public static void Delete( CustomVariable customVariable )
{
Data.DeleteObject<CustomVariable>( customVariable );
}
/// <summary>
///
/// </summary>
/// <param name="customVariable"></param>
public static void Save( CustomVariable customVariable )
{
Data.SaveObject<CustomVariable>( customVariable );
}
public void SaveCustomVariable( CustomVariable customVariable )
{
customVariable.TaskGroupId = this.TaskGroupId;
CustomVariableLogic.Save( customVariable );
// Refresh the list
this.CustomVariables = new ObservableCollection<CustomVariable>( CustomVariableLogic.GetCustomVariablesByGroupId( this.TaskGroupId ) );
ObservableCollection<CustomVariable> customVariables = new ObservableCollection<CustomVariable>();
customVariables.Add( customVariable );
SelectedCustomVariables = customVariables;
}
