public void UseJob(string jobName)
{
CommandArg[] args;
if (fromLoco)
{
args = new CommandArg[]
{
new CommandArg()
{
String = "loco"
},
new CommandArg()
{
String = jobName
}
};
}
else
{
args = new CommandArg[]
{
new CommandArg()
{
String = "job"
},
new CommandArg()
{
String = jobName
}
};
}
BuildRoute(args, this);
}
private void CreateTrackRoute()
{
SetSubPage(typeof(SelectTownStationTrackPage), null, (lastPage) =>
{
SelectTrackPage trackPage = lastPage as SelectTrackPage;
Terminal.Log($"Selected track {trackPage.SelectedTrack}");
CommandArg[] args = new CommandArg[]
{
new CommandArg()
{
String = "from"
},
new CommandArg()
{
String = "loco"
},
new CommandArg()
{
String = "to"
},
new CommandArg()
{
String = trackPage.SelectedTrack
}
};
BuildRoute(args, this);
});
}
private Transform GetPartPosition(CommandArg arg)
{
if (body != null)
{
switch (arg)
{
case CommandArg.TOP:
return(body.transform.Find("TopPosition"));
case CommandArg.FRONT:
return(body.transform.Find("FrontPosition"));
case CommandArg.LEFT:
return(body.transform.Find("LeftPosition"));
case CommandArg.RIGHT:
return(body.transform.Find("RightPosition"));
case CommandArg.BOTTOM:
return(body.transform.Find("BottomPosition"));
default:
return(null);
}
}
return(null);
}
public CommandResult Add(CommandArg arg)
{
CommandResult result = new CommandResult();
try
{
string[] arr = arg.Value.Split(new string[] { "=" }, StringSplitOptions.RemoveEmptyEntries);
if (arr.Length == 0)
{
result.ErrorMessage = "The input does not contain the equal(=) operator or is Empty";
}
else if (arr.Length != 2)
{
result.ErrorMessage = "The input is not well formed.\n Entry format should be as follow: name = value";
}
else
{
string key = (nvCollection.Count() + 1).ToString();
nvCollection.Add(key, arg.Value);
result.NvCollection = nvCollection;
}
}
catch (Exception ex)
{
result.ErrorMessage = ex.Message;
//result.ScalarResult = ex;
}
return(result);
}
public void IListTests()
{
var a0 = new CommandArg("abc");
var a1 = new CommandArg("def");
var d0 = new CommandLine($"--{a0.Name}");
Assert.Single(d0);
d0.Insert(0, a1);
Assert.Equal(a0, d0[a0.Name]);
Assert.False(d0.IsReadOnly);
d0.Clear();
Assert.Empty(d0);
d0.Add(a0);
Assert.True(d0.Contains(a0));
Assert.Single(d0);
var r0 = new CommandArg[1];
d0.CopyTo(r0, 0);
Assert.Equal(a0.Name, r0[0].Name);
Assert.Equal(0, d0.IndexOf(r0[0]));
int i = 0;
foreach (var arg in d0)
{
++i;
}
Assert.Equal(1, i);
Assert.True(d0.Remove(r0[0]));
Assert.Empty(d0);
d0.Add(r0[0]);
d0.RemoveAt(0);
Assert.Empty(d0);
}
public CommandResult SortByValue(CommandArg arg)
{
CommandResult result = new CommandResult();
return(result);
//TODO : Implementation
}
private async void Stop()
{
CommandArg[] args = new CommandArg[]
{
new CommandArg()
{
String = "auto"
},
new CommandArg()
{
String = "stop"
}
};
try
{
await RouteCommand.DoCommand(args);
CallMessageSubPage("Loco AI stopped", "", 1.0f);
}
catch (CommandException exc)
{
RedirectToMessagePage(exc.Message, "MENU");
}
catch (Exception exc)
{
Terminal.Log(exc.Message + ": " + exc.StackTrace);
RedirectToMessagePage("Error LocoAI, see console", "MENU");
}
}
protected void bottonClickAction(object sender, EventArgs e)
{
Button button = sender as Button;
string buttonName = button.ID;
Icommand command = CommandFactory.CreateCommand(buttonName);
CommandArg cmdArg = new CommandArg();
CommandResult results = null;
cmdArg.Value = txtNameValuePair.Text;
cmdArg.ListBox = ListBox1;
if (command != null)
{
results = command.Execute(cmdArg);
if (results.ErrorMessage == "")
{
ListBox1.DataSource = results.NvCollection;
ListBox1.DataBind();
errorLabel.Text = "";
}
else
{
errorLabel.Text = results.ErrorMessage;
errorLabel.ForeColor = System.Drawing.Color.Red;
errorLabel.Font.Size = FontUnit.Larger;
}
}
}
public CommandResult ClearFilter(CommandArg arg)
{
CommandResult result = new CommandResult();
return(result);
//TODO : Implementation
}
public void SetPart(PartEnum partEnum, CommandArg arg)
{
if (body == null)
{
return;
}
switch (arg)
{
case CommandArg.TOP:
InstantiatePart(ref topPart, partEnum, arg);
break;
case CommandArg.FRONT:
InstantiatePart(ref frontPart, partEnum, arg);
break;
case CommandArg.LEFT:
InstantiatePart(ref leftPart, partEnum, arg);
break;
case CommandArg.RIGHT:
InstantiatePart(ref rightPart, partEnum, arg);
break;
case CommandArg.BOTTOM:
InstantiatePart(ref bottomPart, partEnum, arg);
break;
default:
break;
}
}
public static bool IsVehicle(this CommandArg arg, out VehicleAsset value)
{
if (arg.IsUInt16(out ushort id))
{
Asset asset = Assets.find(EAssetType.VEHICLE, id);
if (asset == null)
{
value = null;
return(false);
}
value = (VehicleAsset)asset;
return(value != null);
}
else if (arg.IsGuid(out Guid guid))
{
value = AssetUtil.GetVehicleAssets().FirstOrDefault(d => d.GUID == guid);
return(value != null);
}
else
{
string search = arg.RawValue.StartsWith("@") ? arg.RawValue.Substring(1) : arg.RawValue;
value = AssetUtil.GetVehicleAsset(search);
return(value != null);
}
}
/// <summary>
/// BackgroundWorker開始する
/// </summary>
/// <param name="arg"></param>
private void Run(CommandArg arg)
{
this.mnuPanel.Enabled = false;
this.lblParcentage.Text = "";
this.lblMessage.Text = "";
this.progressBar1.Value = 0;
this.ProgressPanel.Visible = true;
this.ProgressPanel.BringToFront();
this.backgroundWorker1.RunWorkerAsync(arg);
}
public void CtorNullTest()
{
var d = new CommandArg();
Assert.Equal("", d.Name);
Assert.False(d.IsSwitch);
Assert.False(d.IsPositional);
Assert.True(d.IsNull);
Assert.Null(d.Value);
Assert.Null(d.ResolvedValue);
}
public CommandResult SortByName(CommandArg arg)
{
CommandResult result = new CommandResult();
var sorted = from nv in nvCollection
orderby nv.Value.Split('=')[0] ascending
select nv;
//TODO : Implementation
return(result);
}
/// <summary>
/// BackgroundWorker開始イベントを処理する
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
{
try
{
CommandArg commandArg = (CommandArg)e.Argument;
switch (commandArg.Kind)
{
case CommandKind.TableScriptCreate:
DoCreateSqlScript((TableCreateInfo)commandArg.Params[0]);
break;
case CommandKind.SeedDataSheetCreate:
this.DoCreateDataSheet((string[])commandArg.Params, false);
break;
case CommandKind.LiveDataSheetCreate:
this.DoCreateDataSheet((string[])commandArg.Params, true);
break;
case CommandKind.LiveInsertSqlCreate:
this.DoInsertSqlScript((string)commandArg.Params[0], true);
break;
case CommandKind.SeedInsertSqlCreate:
this.DoInsertSqlScript((string)commandArg.Params[0], false);
break;
case CommandKind.ProductionDataCheck:
DoCheckDatas(DataKind.ProductionData, (string)commandArg.Params[0]);
break;
case CommandKind.OperationDataCheck:
DoCheckDatas(DataKind.OperationData, (string)commandArg.Params[0]);
break;
case CommandKind.DenshowDataSheetCreate:
this.DoCreateDenshowDataSheet((string[])commandArg.Params);
break;
case CommandKind.DenshowInsertSqlCreate:
this.DoDenshowInsertSqlScript((string)commandArg.Params[0]);
break;
default:
break;
}
}
catch (Exception ex)
{
Logging.Exception("", ex);
throw ex;
}
}
/// <param name="value">Parsed value</param>
/// <returns>Parsed</returns>
/// <exception cref="ArgumentException"/>
public static bool IsEnum <T>(this CommandArg arg, out T value) where T : struct, IConvertible
{
if (!typeof(T).IsEnum)
{
throw new ArgumentException($"{typeof(T).Name} is not an enum");
}
var isDefined = arg.RawValue == null ? false : Enum.IsDefined(typeof(T), arg.RawValue);
value = isDefined ? (T)Enum.Parse(typeof(T), arg.RawValue) : default;
return(isDefined);
}
public void CtorSwitchTest()
{
string n0 = "a";
var d = new CommandArg(n0);
Assert.Equal(n0, d.Name);
Assert.True(d.IsSwitch);
Assert.False(d.IsPositional);
Assert.False(d.IsNull);
Assert.Null(d.Value);
Assert.Null(d.ResolvedValue);
}
private void ChangeRouteDirection()
{
CommandArg[] args = new CommandArg[]
{
new CommandArg()
{
String = "opposite"
}
};
NewRoutePage.BuildRoute(args, this);
}
private void AttachPartToBody(PartComponent o, CommandArg commandArg)
{
if (o == null)
{
return;
}
Transform targetTransform = GetPartPosition(commandArg);
o.transform.SetParent(targetTransform);
o.transform.localPosition = Vector3.zero;
o.transform.localRotation = Quaternion.identity;
o.transform.localScale = Vector3.one;
}
public static bool IsCSteamID(this CommandArg arg, out CSteamID value)
{
value = default;
if (arg.IsUInt64(out ulong id))
{
value = new CSteamID(id);
return(true);
}
else
{
return(false);
}
}
/// <param name="value">Parsed value</param>
/// <returns>Parsed</returns>
public static bool IsGuid(this CommandArg arg, out Guid value)
{
try
{
value = new Guid(arg.RawValue);
return(true);
}
catch (FormatException)
{
value = Guid.Empty;
return(false);
}
}
public void CtorPositionalTest()
{
string v0 = "a";
int i0 = 1;
var d = new CommandArg(i0, v0);
Assert.Equal($"Arg{i0}", d.Name);
Assert.False(d.IsSwitch);
Assert.True(d.IsPositional);
Assert.False(d.IsNull);
Assert.Equal(i0, d.PositionIndex);
Assert.Equal(v0, d.Value);
Assert.Equal(v0, d.ResolvedValue as string);
}
public static bool IsPlayers(this CommandArg arg, out IEnumerable <UnturnedPlayer> value)
{
List <UnturnedPlayer> res = new List <UnturnedPlayer>();
if (arg.RawValue == "*")
{
res.AddRange(ProviderExtension.GetUnturnedPlayers());
}
else if (arg.IsPlayer(out UnturnedPlayer player))
{
res.Add(player);
}
value = res;
return(value.Count() > 0);
}
private void InstantiatePart(ref PartComponent partComponent, PartEnum partEnum, CommandArg arg)
{
if (partComponent != null)
{
Destroy(partComponent.gameObject);
}
if (partEnum != PartEnum.NONE)
{
partComponent = Instantiate(_entitiesPrefabs.GetPrefabFromEnum(partEnum), GetPartPosition(arg))
.GetComponent <PartComponent>();
partComponent.SetPrimaryColor(primaryColor);
partComponent.SetSecondaryColor(secondaryColor);
}
}
private void CreateTrackRoute()
{
SetSubPage(typeof(SelectTownStationTrackPage), null, async(lastPage) =>
{
SelectTrackPage trackPage = lastPage as SelectTrackPage;
Terminal.Log($"Selected track {trackPage.SelectedTrack}");
CommandArg[] args = new CommandArg[]
{
new CommandArg()
{
String = "auto"
},
new CommandArg()
{
String = trackPage.SelectedTrack
}
};
try
{
await RouteCommand.DoCommand(args);
DisplayText($"Going to {trackPage.SelectedTrack}", "");
await new WaitForSeconds(1.0f);
DisplayText(menuSelector.Current.displayText, menuSelector.Current.actionName);
}
catch (CommandException exc)
{
RedirectToMessagePage(exc.Message, "MENU");
}
catch (Exception exc)
{
Terminal.Log(exc.Message + ": " + exc.StackTrace);
RedirectToMessagePage("Error LocoAI, see console", "MENU");
}
});
}
public CommandResult Remove(CommandArg arg)
{
CommandResult result = new CommandResult();
try
{
if (arg.ListBox.SelectedIndex != -1)
{
string key = (arg.ListBox.SelectedIndex + 1).ToString();
nvCollection.Remove(key);
result.NvCollection = nvCollection;
}
else
{
result.ErrorMessage = "You have not selected an Item in order to delete it.";
}
}
catch (Exception ex)
{
result.ErrorMessage = ex.Message;
}
return(result);
}
public CommandResult Execute(CommandArg cmdArg)
{
CommandResult result = Utility.Instance.Remove(cmdArg);
return(result);
}
/// <param name="value">Parsed value</param>
/// <returns>Parsed</returns>
public static bool IsDateTime(this CommandArg arg, out DateTime value)
{
return(DateTime.TryParse(arg.RawValue, Culture, DateTimeStyles.None, out value));
}
public void SetPart(PartEnum partEnum, CommandArg twitchcommandArgument)
{
PlayerAction();
decoration.SetPart(partEnum, twitchcommandArgument);
}
/// <param name="value">Parsed value</param>
/// <returns>Parsed</returns>
public static bool IsDecimal(this CommandArg arg, out decimal value)
{
return(decimal.TryParse(arg.RawValue, NumberStyles.Number, Culture, out value));
}
