// Process a GameObject variable action
bool DoGameObjectAction(VariableAction variableAction, FsmGameObject fsmGameObject, string key, bool isGlobal, int index = 0)
{
// Check for empty GameObject
if (fsmGameObject.Value == null)
{
Debug.Log("Cannot save or load null GameObject reference: " + fsmGameObject.Name, Owner);
return(false);
}
if (variableAction == VariableAction.CopyVariableToPool)
{
return(GameObjectToPool(fsmGameObject, key, isGlobal, index));
}
else if (variableAction == VariableAction.CopyPoolToVariable)
{
var success = PoolToGameObject(fsmGameObject, key, isGlobal, index);
if (success)
{
return(true);
}
else
{
Debug.Log("Variable data not found in pool: " + fsmGameObject.Name, Owner);
return(false);
}
}
else
{
throw new ArgumentException("variableAction", "Invalid variable action: " + variableAction);
}
}
public CalcAffordanceVariableOp([NotNull] string name, double value, [NotNull] CalcLocation location, VariableAction variableAction,
VariableExecutionTime executionTime, StrGuid variableGuid)
{
Name = name;
Value = value;
CalcLocation = location;
VariableAction = variableAction;
ExecutionTime = executionTime;
VariableGuid = variableGuid;
}
public ExecutionEntry([NotNull] string name, double value, [NotNull] CalcLocation location, VariableAction variableAction,
[NotNull] TimeStep timeStep, StrGuid variableGuid)
{
_variableGuid = variableGuid;
Name = name;
Value = value;
CalcLocation = location;
VariableAction = variableAction;
TimeStep = timeStep;
}
public SubAffordanceVariableOp(double value, [CanBeNull] int?id, int affordanceID, [NotNull] string connectionString,
VariableLocationMode variableLocationMode, [CanBeNull] Location location, VariableAction variableAction,
[CanBeNull] Variable variable, VariableExecutionTime executionTime, [NotNull] string name, StrGuid guid) : base(name, TableName,
connectionString, guid)
{
_value = value;
ID = id;
_affordanceID = affordanceID;
TypeDescription = "SubAffordance Variable Operation";
_variableLocationMode = variableLocationMode;
_location = location;
_variableAction = variableAction;
_variable = variable;
_executionTime = executionTime;
}
public VariablesUI(VariableAction action)
{
InitializeComponent();
this.action = action;
#region initialize resources
button1.Content = Properties.Resources.Strings["ui_3:btn_1"][0];
button2.Content = Properties.Resources.Strings["ui_3:btn_2"][0];
column1.Header = Properties.Resources.Strings["ui_3:col_1"][0];
column2.Header = Properties.Resources.Strings["ui_3:col_2"][0];
column3.Header = Properties.Resources.Strings["ui_3:col_3"][0];
column4.Header = Properties.Resources.Strings["ui_3:col_4"][0];
column1.HeaderStyle = GetHeaderStyle(Properties.Resources.Strings["ui_3:col_1"][1]);
column2.HeaderStyle = GetHeaderStyle(Properties.Resources.Strings["ui_3:col_2"][1]);
column3.HeaderStyle = GetHeaderStyle(Properties.Resources.Strings["ui_3:col_3"][1]);
column4.HeaderStyle = GetHeaderStyle(Properties.Resources.Strings["ui_3:col_4"][1]);
column5.HeaderStyle = GetHeaderStyle(Properties.Resources.Strings["ui_3:col_5"][1]);
#endregion
switch (action)
{
case VariableAction.Add:
column2.Visibility = Visibility.Collapsed;
break;
case VariableAction.Edit:
column2.Visibility = Visibility.Collapsed;
break;
case VariableAction.Rename:
column3.Visibility = Visibility.Collapsed;
column4.Visibility = Visibility.Collapsed;
column5.Visibility = Visibility.Collapsed;
Width = 500;
break;
case VariableAction.Remove:
column2.Visibility = Visibility.Collapsed;
column3.Visibility = Visibility.Collapsed;
column4.Visibility = Visibility.Collapsed;
column5.Visibility = Visibility.Collapsed;
Width = 300;
break;
}
}
private void Button1_Click(object sender, RoutedEventArgs e)
{
PropertyItem pi = DataContext as PropertyItem;
VariableAction action = VariableAction.Add;
switch (pi.PropertyName)
{
case "EditVariables":
action = VariableAction.Edit;
break;
case "RenameVariables":
action = VariableAction.Rename;
break;
case "RemoveVariables":
action = VariableAction.Remove;
break;
}
VariablesUI vui = new VariablesUI(action)
{
Title = pi.DisplayName,
Owner = Window.GetWindow(Parent),
WindowStartupLocation = WindowStartupLocation.CenterOwner,
DataSource = Value
};
if (vui.ShowDialog() == true)
{
textbox.Text = string.Format("[{0}]", Value.Count());
using (UndoRedoManager.Start(pi.PropertyName))
{
variables.Value = Value.Clone() as VariableCollection;
UndoRedoManager.Commit();
}
//Debug.WriteLine(string.Format("Commit: [name: {0}, value: {1}]",
// pi.PropertyName, Value.Data));
}
}
public static string ConvertToVariableDescription(VariableAction tc)
{
var entries = MakeAllEntries();
return(entries.First(x => x.Action == tc).Description);
}
public VariableActionHelperEntry(VariableAction action, [NotNull] string description)
{
Action = action;
Description = description;
}
// Perform an action with an FSM variable
protected bool DoVariableAction(VariableAction variableAction, NamedVariable fsmVariable, string key, bool?isGlobal = null)
{
// Check data
if (fsmVariable == null)
{
throw new ArgumentNullException("fsmVariable", "Cannot do action with null variable: " + variableAction);
}
// If no current pool, get one
if (_dataPool == null)
{
DefaultDataPool();
}
// Get global state
if (isGlobal == null)
{
isGlobal = FsmVariables.GlobalVariables.Contains(fsmVariable);
}
// If GameObject, do action and exit
if (fsmVariable.VariableType == VariableType.GameObject)
{
return(DoGameObjectAction(variableAction, (FsmGameObject)fsmVariable, key, (bool)isGlobal));
}
// If array of GameObjects, do actions and exit
if (fsmVariable.VariableType == VariableType.Array)
{
if (((FsmArray)fsmVariable).ElementType == VariableType.GameObject)
{
var allSuccess = true;
for (int index = 0; index < ((FsmArray)fsmVariable).Values.Length; index++)
{
if (!DoGameObjectAction(variableAction, new FsmGameObject(fsmVariable.Name)
{
Value = (GameObject)((FsmArray)fsmVariable).Values[index]
}, key, (bool)isGlobal, index))
{
allSuccess = false;
}
}
return(allSuccess);
}
}
// Search data pool for new data source
var newDataSource = new SmoothSaveDataSource(fsmVariable, key, (bool)isGlobal, Fsm);
var oldDataSource = FindDataSource(newDataSource);
// Copy variable to pool
if (variableAction == VariableAction.CopyVariableToPool)
{
// If found, remove old copy
if (oldDataSource != null)
{
_dataPool.DataSources.Remove(oldDataSource);
}
_dataPool.DataSources.Add(newDataSource);
return(true);
}
// Copy pool to variable
else if (variableAction == VariableAction.CopyPoolToVariable)
{
if (oldDataSource != null)
{
// If no FSM variable, set it
if (oldDataSource.GetFsmVariable() == null)
{
oldDataSource.SetFsmVariable(newDataSource);
}
oldDataSource.Deserialize();
return(true);
}
else
{
Debug.Log("Variable data not found in pool: " + fsmVariable.Name, Owner);
return(false);
}
}
else
{
throw new ArgumentException("Invalid variable action: " + variableAction);
}
}
// Perform an action with a batch of FSM variables
protected bool DoBatchVariableAction(FsmVariables fsmVariables, VariableAction variableAction, string filter, FsmVariableType fsmVariableType)
{
// Check data
if (fsmVariables == null)
{
throw new ArgumentNullException("fsmVariables", "Cannot do action with null FSM variable batch: " + variableAction);
}
NamedVariable[] fsmVariableSubset;
switch (fsmVariableType)
{
case FsmVariableType.All:
fsmVariableSubset = fsmVariables.GetAllNamedVariables();
break;
case FsmVariableType.Bool:
fsmVariableSubset = fsmVariables.BoolVariables;
break;
case FsmVariableType.Color:
fsmVariableSubset = fsmVariables.ColorVariables;
break;
case FsmVariableType.Float:
fsmVariableSubset = fsmVariables.FloatVariables;
break;
case FsmVariableType.GameObject:
fsmVariableSubset = fsmVariables.GameObjectVariables;
break;
case FsmVariableType.Int:
fsmVariableSubset = fsmVariables.IntVariables;
break;
case FsmVariableType.Quaternion:
fsmVariableSubset = fsmVariables.QuaternionVariables;
break;
case FsmVariableType.Rect:
fsmVariableSubset = fsmVariables.RectVariables;
break;
case FsmVariableType.String:
fsmVariableSubset = fsmVariables.StringVariables;
break;
case FsmVariableType.Vector2:
fsmVariableSubset = fsmVariables.Vector2Variables;
break;
case FsmVariableType.Vector3:
fsmVariableSubset = fsmVariables.Vector3Variables;
break;
case FsmVariableType.Array:
fsmVariableSubset = fsmVariables.ArrayVariables;
break;
case FsmVariableType.Enum:
fsmVariableSubset = fsmVariables.EnumVariables;
break;
default:
throw new NotSupportedException("Invalid FSM variable type: " + fsmVariableType);
}
// Process each FSM variable
var allComplete = true;
foreach (var currentVariable in fsmVariableSubset)
{
if (MatchFilter(currentVariable.Name, filter) && IsValidFsmVariableType(currentVariable))
{
if (!DoVariableAction(variableAction, currentVariable, null))
{
allComplete = false;
}
}
}
return(allComplete);
}
public void AddExecutionEntry([NotNull] string name, double value, [NotNull] CalcLocation location, VariableAction variableAction,
[NotNull] TimeStep timeStep, StrGuid variableGuid)
{
_variableOperator.AddEntry(name, value, location, variableAction,
timeStep, variableGuid);
}
static void Main(string[] args)
{
var app = new CommandLineApplication();
app.Name = "taide";
app.Description = ".NET Core console app with argument parsing.";
app.HelpOption(helpValues);
var basicOption = app.Option("-o|--option<optionvalue>",
"Some option value",
CommandOptionType.SingleValue);
app.OnExecute(() => {
if (basicOption.HasValue())
{
Console.WriteLine("Option was selected, value: {0}", basicOption.Value());
}
else
{
app.ShowHint();
}
return(0);
});
app.Command("setup", (command) => {
command.Description = "Creates commonly used variables and modules in Terraform project.";
command.HelpOption(helpValues);
command.OnExecute(() => {
var action = new SetupAction();
action.Execute();
return(0);
});
});
app.Command("create", (command) => {
command.Description = "Creates a new Terraform project folder in the current directory.";
command.HelpOption(helpValues);
command.OnExecute(() => {
var action = new CreateAction();
action.Execute();
return(0);
});
});
app.Command("module", (command) => {
command.Description = "";
command.HelpOption(helpValues);
command.OnExecute(() => {
var action = new ModuleAction();
action.Execute();
return(0);
});
});
app.Command("variable", (command) => {
command.Description = "";
command.HelpOption(helpValues);
command.OnExecute(() => {
var action = new VariableAction();
action.Execute();
return(0);
});
});
app.Command("test", (command) => {
command.Description = "";
command.HelpOption(helpValues);
command.OnExecute(() => {
var action = new TestAction();
action.Execute();
return(0);
});
});
app.Execute(args);
#if DEBUG
Console.WriteLine("Press any key to close...");
Console.ReadKey();
#endif
}
public void AddEntry([NotNull] string name, double value, [NotNull] CalcLocation location, VariableAction variableAction,
[NotNull] TimeStep timeStep, StrGuid variableGuid)
{
var ee = new ExecutionEntry(name, value, location, variableAction,
timeStep, variableGuid);
_entries.Add(ee);
}
