public static void Start()
{
RuntimeObject.Init();
RigidBody.Init();
CollisionBody.Init();
CollisionSensor.Init();
TransportSurface.Init();
CollisionMaterial.Init();
HingeJoint.Init();
SlidingJoint.Init();
CylindricalJoint.Init();
FixedJoint.Init();
BallJoint.Init();
AngularLimit.Init();
LinearLimit.Init();
AngularSpring.Init();
LinearSpring.Init();
SpeedControl.Init();
PositionControl.Init();
BreakingConstraint.Init();
GearCoupling.Init();
CamCoupling.Init();
ElecCamCoupling.Init();
PreventCollision.Init();
ChangeMaterial.Init();
ComponentPart.Init();
SourceBehavior.Init();
SinkBehavior.Init();
GraphControl.Init();
ExternalConnection.Init();
SignalAdapter.Init();
Signal.Init();
ProxyObject.Init();
RuntimeParameters.Init();
}
public static int Main(string [] args)
{
// Create a new RuntimeParameters to parse the args
RuntimeParameters parameters = new RuntimeParameters(
"HelloWorldNodeDataHandler",
"HelloWorld using IDataHandler/ISender paradigm");
// Parse the args, if we don't get 0 back, there was an error
if (parameters.Parse(args) != 0)
{
// Print the error and help
Console.WriteLine(parameters.ErrorMessage);
parameters.ShowHelp();
// exit after error
return(-1);
}
else if (parameters.Help)
{
// Caller asked for help, let's print it
parameters.ShowHelp();
// exit after printing help
return(0);
}
// Instantiate a new inherited node of your choice
HelloWorldNodeDataHandler hwn =
new HelloWorldNodeDataHandler(parameters.NodeConfig);
// And run it... this hijacks the current thread, we'll return once the node disconnects
hwn.Run();
Console.WriteLine("Exiting...");
return(0);
}
public static string[] GetImageDependencies(AbilityDataSubclass[] target)
{
HashSet <string> imageDependencies = new HashSet <string>();
for (int i = 0; i < target.Length; i++)
{
for (int j = 0; j < target[i].var.Length; j++)
{
if (LoadedData.GetVariableType(target[i].classType, j, VariableTypes.IMAGE_DEPENDENCY))
{
RuntimeParameters <string> imagePath = target[i].var[j].field as RuntimeParameters <string>;
if (!imageDependencies.Contains(imagePath.v))
{
imageDependencies.Add(imagePath.v);
}
}
}
}
string[] sArray = new string[imageDependencies.Count];
int index = 0;
foreach (string path in imageDependencies)
{
sArray[index] = path;
index++;
}
return(sArray);
//return imageDependencies.ToArray();
}
public void RunAccordingToGeneric <T, P>(P arg)
{
int subclass = ((int[])(object)arg)[0];
int oldId = ((int[])(object)arg)[1];
int newId = ((int[])(object)arg)[2];
RuntimeParameters <T> rP = null;
try {
rP = JsonConvert.DeserializeObject <RuntimeParameters <T> >(standardFiles[subclass].rP[oldId]);
} catch (Exception e) {
Debug.Log("Could not convert. Reverting to source.");
}
int[][] links = JsonConvert.DeserializeObject <int[][]>(standardFiles[subclass].l[oldId]);
if (rP != null)
{
convertedFormat[subclass].var[newId] = new Variable(rP, links);
}
else
{
convertedFormat[subclass].var[newId] = new Variable(LoadedData.loadedParamInstances[convertedFormat[subclass].classType].runtimeParameters[newId].rP, links);
}
}
private void Vision_FormClosing(object sender, FormClosingEventArgs e)
{
if (!normalExit)
{
if (!mainForm.RecipeChangeover)
{
if (DialogResult.Yes == MessageBox.Show("Save changes?", "Save?", MessageBoxButtons.YesNo))
{
saveParameters = true;
}
}
}
if (saveParameters)
{
mainForm.SerializeRuntimeParameters(runtimeParameters);
}
else
{
// Reload the recipe
bool success;
restoreParameters = mainForm.DeserializeRuntimeParamters(mainForm.RecipeName + ".xml", out success);
if (!success)
{
MessageBox.Show("Error reading recipe file.", "Warning!");
return;
}
}
}
public void Initialize(PatternDefinition def)
{
definition = def;
Debug.Log("Starting Pattern: " + definition.name);
runParams = new RuntimeParameters()
{
rotationSpeed = def.rotationSpeed
};
// Spawn Points
GameObject pointsParentGo = new GameObject("AttackPoints Root");
runParams.pointsParent = pointsParentGo.transform;
runParams.pointsParent.SetParent(transform);
runParams.attackPoints = definition.CreateSpawnPoints(runParams.pointsParent);
// Sequence
procManager = new ProcessManager();
sequenceProcess = new SequenceProcess(definition.sequence, runParams, definition.finishedDelay);
sequenceProcess.TerminateCallback += SequenceFinished;
procManager.LaunchProcess(sequenceProcess);
// Simultaneous Patterns
foreach (PatternDefinition defSimult in definition.simultaneous)
{
defSimult.Attach(gameObject).suppressNext = true;
}
}
public override SpawnerOutput ReturnCustomUI(int variable, RuntimeParameters rp)
{
int p = GetVariableId("Point");
if (p == variable)
{
SpawnerOutput pField = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(DropdownWrapper));
Dropdown dW = LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Dropdown>(pField);
List <Dropdown.OptionData> dOd = new List <Dropdown.OptionData>();
RuntimeParameters <int> rpI = rp as RuntimeParameters <int>;
dOd.Add(new Dropdown.OptionData("X"));
dOd.Add(new Dropdown.OptionData("Y"));
dW.AddOptions(dOd);
dW.value = rpI.v;
dW.onValueChanged.AddListener((id) => {
rpI.v = id;
});
return(pField);
}
return(base.ReturnCustomUI(variable, rp));
}
static void Main(string[] p_Args)
{
RuntimeParameters runtimeParameters = new RuntimeParameters();
var optionSet = new OptionSet {
{ "d|directory-path=", "Absolute path to the repository to update.", value => runtimeParameters.DirectoryPath = value },
{ "u|hosting-username="******"Username used with the hosting platform.", value => runtimeParameters.Username = value },
{ "p|hosting-password="******"Password used with the hosting platform.", value => runtimeParameters.Password = value },
{ "h|help", "Show this message", value => runtimeParameters.Help = value != null }
};
try {
optionSet.Parse(p_Args);
} catch (OptionException e) {
s_Logger.Error(e.Message);
s_Logger.Info("Try `--help` for more information.");
return;
}
if (runtimeParameters.Help)
{
ShowHelp(optionSet);
return;
}
if (!runtimeParameters.Validate())
{
s_Logger.Error("Invalid arguments.");
s_Logger.Info("Try `--help` for more information.");
return;
}
Run(runtimeParameters);
}
private Nar(CompoundAndTermContext compoundAndTermContext, RuntimeParameters runtimeParameters)
{
Memory m = createMemory(compoundAndTermContext, runtimeParameters);
this.memory = m;
this.param = runtimeParameters;
}
public Stats(MainForm mf, RuntimeParameters rp)
{
InitializeComponent();
mainForm = mf;
runtimeParameters = rp;
}
public Engineering(AbbCom.Client lc, MachineConfig mc, RuntimeParameters rp, MainForm mf)
{
logClient = lc;
machineParameters = mc;
runtimeParameters = rp;
mainForm = mf;
InitializeComponent();
}
public override void NodeCallback()
{
base.NodeCallback();
int[] arrayValues = GetCentralInst().GetVariableLinks(0, GetNodeId(), GetVariableId("Values"))[GetNodeVariable <int>("Array Element")];
RuntimeParameters targetVar = GetCentralInst().ReturnRuntimeParameter(arrayValues[0], arrayValues[1]);
targetVar.RunGenericBasedOnRP <RuntimeParameters>(this, targetVar);
}
public AcqFifoAdjust(MainForm mf, RuntimeParameters rp, CogJobManager cjm)
{
InitializeComponent();
mainForm = mf;
runtimeParameters = rp;
restoreParameters = rp.ShallowCopy();
mcjmAcq = cjm;
}
public void MaliciousRuntimeParametersAreDenied()
{
RuntimeParameters maliciousConfig = new RuntimeParameters {
DirectoryPath = "rm -rf",
Username = "******",
Password = "******"
};
Assert.False(maliciousConfig.Validate());
}
public Vision(MainForm mf, RuntimeParameters rp, CogJobManager cjm, MachineConfig mc)
{
InitializeComponent();
mainForm = mf;
runtimeParameters = rp;
machineParameters = mc;
restoreParameters = rp.ShallowCopy();
mcjmAcq = cjm;
}
private static void Run(RuntimeParameters p_RuntimeParameters)
{
NureOptions nureOptions;
try {
TextReader json = File.OpenText(Path.Combine(p_RuntimeParameters.DirectoryPath, CONFIGURATION_FILE_NAME));
nureOptions = JsonSerializer.CreateDefault().Deserialize <NureOptions>(new JsonTextReader(json));
s_Logger.Info("Launching NuRe with the following configuration:\n" + nureOptions);
} catch (FileNotFoundException exception) {
s_Logger.Error($"Could not locate the file. {exception.Message}");
return;
}
var gitWrapper = new GitAgent(nureOptions.CommitMessage);
string remoteName = "origin";
string branchName;
try {
gitWrapper.CreateRepository(p_RuntimeParameters.DirectoryPath);
gitWrapper.Fetch(p_RuntimeParameters, remoteName, nureOptions.HostingUrl);
branchName = gitWrapper.SetupBranch(nureOptions.NureBranchPrefix, remoteName);
} catch (LibGit2SharpException exception) {
s_Logger.Error($"Could not setup the branch. {exception.Message}");
return;
} catch (InvalidProgramException exception) {
s_Logger.Error($"Could not create the repository. {exception.Message}");
return;
} catch (UriFormatException exception) {
s_Logger.Error($"Could not fetch the repository. Hosting Url: {nureOptions.HostingUrl}. {exception.Message}");
return;
}
NuKeeperWrapper nukeeper = new NuKeeperWrapper(nureOptions, p_RuntimeParameters.DirectoryPath);
nukeeper.Run();
s_Logger.Info("Run Complete");
gitWrapper.Stage();
//todo get them from the options file
Identity identity = new Identity("Jenkins", "*****@*****.**");
Signature signature = new Signature(identity, DateTimeOffset.Now);
try {
gitWrapper.Commit(signature);
gitWrapper.Push(p_RuntimeParameters);
} catch (LibGit2SharpException exception) {
s_Logger.Error($"Could not setup the branch. {exception.Message}");
return;
}
var pullRequestWriterFactory = new PullRequestWriterFactory(nureOptions, p_RuntimeParameters.Username, p_RuntimeParameters.Password);
pullRequestWriterFactory.Create().WritePullRequest(branchName);
}
static void Main(string[] args)
{
var runtimeParameters = new RuntimeParameters(args);
var environmentContext = new EnvironmentContext(runtimeParameters);
var globalContext = new GlobalContext(environmentContext);
var processor = new LocationProcessor(globalContext);
processor.Process();
Console.ReadLine();
}
static Memory createMemory(CompoundAndTermContext compoundAndTermContext, RuntimeParameters runtimeParameters)
{
IAttentionMechanism <ClassicalTask> attentionMechanism = new BagBasedAttentionMechanism();
attentionMechanism.setMaxSize(Parameters.NOVEL_TASK_BAG_SIZE);
return(new Memory(
compoundAndTermContext,
runtimeParameters,
attentionMechanism
//commented because OpenNARS version new ArrayBag<>(Parameters.SEQUENCE_BAG_LEVELS, Parameters.SEQUENCE_BAG_SIZE)
));
}
public override SpawnerOutput ReturnCustomUI(int variable, RuntimeParameters rp)
{
if (variable == GetVariableId("Input Key"))
{
KeyCodeDropdownList kcDdL = new KeyCodeDropdownList((rp as RuntimeParameters <int>).v);
kcDdL.ReturnDropdownWrapper().dropdown.onValueChanged.AddListener((v) => {
(rp as RuntimeParameters <int>).v = KeyCodeDropdownList.inputValues[v];
});
return(kcDdL.dW);
}
return(base.ReturnCustomUI(variable, rp));
}
public void Push(RuntimeParameters p_Parameters)
{
s_Logger.Info($"Pushing {m_BranchName}.");
PushOptions options = new PushOptions {
CredentialsProvider = (url,
usernameFromUrl,
types) =>
new UsernamePasswordCredentials {
Username = p_Parameters.Username, Password = p_Parameters.Password
}
};
m_Repository.Network.Push(m_Repository.Branches[m_BranchName], options);
s_Logger.Info("Push Complete.");
}
public void MissingRuntimeParametersAreDetected()
{
var missingPassword = new RuntimeParameters {
DirectoryPath = "/bin/bash", Username = "******"
};
var missingPath = new RuntimeParameters {
Username = "******", Password = "******"
};
var missingUser = new RuntimeParameters {
DirectoryPath = "/bin/bash", Password = "******"
};
Assert.False(missingPassword.Validate());
Assert.False(missingPath.Validate());
Assert.False(missingUser.Validate());
}
private void buttonPatternParams_Click(object sender, EventArgs e)
{
bool success;
runtimeParameters = mainForm.DeserializeRuntimeParamters(mainForm.RecipeName + ".xml", out success);
if (!success)
{
MessageBox.Show("Error reading 'runtimeParameters' file.", "Warning!");
return;
}
using (PatternParams ca = new PatternParams(mainForm, runtimeParameters, machineParameters, mcjmAcq))
{
ca.ShowDialog();
}
}
private void buttonGreyscaleAdvanced_Click(object sender, EventArgs e)
{
bool success;
runtimeParameters = mainForm.DeserializeRuntimeParamters(mainForm.RecipeName + ".xml", out success);
if (!success)
{
MessageBox.Show("Error reading 'runtimeParameters' file.", "Warning!");
return;
}
using (AcqFifoAdjust acq = new AcqFifoAdjust(mainForm, runtimeParameters, mcjmAcq))
{
acq.ShowDialog();
}
}
/// <summary>
/// Setup the operating environment
/// </summary>
/// <param name="environment">Environment to process within.</param>
private void SetEnvironmentContext(RuntimeParameters runtimeParameters)
{
_environment = !string.IsNullOrWhiteSpace(runtimeParameters.Environment) ? runtimeParameters.Environment : "local";
_indexLanguage = !string.IsNullOrWhiteSpace(runtimeParameters.IndexLanguage) ? runtimeParameters.IndexLanguage : "en";
_build = runtimeParameters.Build;
SetSqlEnvironments();
SetCountriesToBeIndexed();
SetLanguageCodes();
SetIndexName();
SetXmlDocumentsDestinationPath();
//SetElasticsearchConnString(environment);
//SetShardsReplicasValues(environment);
//SetDocumentPartitionTargetSizeMultiplier(environment);
}
public static RuntimeParameters[] ReturnNodeVariables(Type nodeT)
{
if (loadedParamInstances.ContainsKey(nodeT))
{
RuntimeParameters[] rP = new RuntimeParameters[loadedParamInstances[nodeT].runtimeParameters.Length];
for (int i = 0; i < rP.Length; i++)
{
rP[i] = loadedParamInstances[nodeT].runtimeParameters[i].rP;
}
return(rP);
}
return(null);
}
public Memory(
CompoundAndTermContext compoundAndTermContext,
RuntimeParameters runtimeParameters,
IAttentionMechanism <ClassicalTask> attention
)
{
this.compoundAndTermContext = compoundAndTermContext;
this.param = runtimeParameters;
this.attention = attention;
conceptProcessing = new ClassicalConceptProcessing(this, compoundAndTermContext);
workingCyclish = new WorkingCyclish();
workingCyclish.concepts = new ArrayBag <ClassicalConcept, TermOrCompoundTermOrVariableReferer>();
workingCyclish.concepts.setMaxSize(Parameters.CONCEPT_BAG_SIZE);
}
private void Engineering_Load(object sender, EventArgs e)
{
bool success;
runtimeParameters = mainForm.DeserializeRuntimeParamters(mainForm.RecipeName + ".xml", out success);
if (!success)
{
MessageBox.Show("Error reading recipe file.", "Warning!");
return;
}
if (logClient.Running)
{
buttonStartLogger.Enabled = false;
buttonStopLogger.Enabled = true;
buttonSend.Enabled = true;
}
else
{
buttonStartLogger.Enabled = true;
buttonStopLogger.Enabled = false;
buttonSend.Enabled = false;
}
textBoxCogJobBlob.Text = runtimeParameters.VisCogJobBlobName;
textBoxCogJobPattern.Text = runtimeParameters.VisCogJobPatternName;
lastBlobName = textBoxCogJobBlob.Text;
lastPatternName = textBoxCogJobPattern.Text;
textBoxCogJobBlob.Enabled = false;
textBoxCogJobPattern.Enabled = false;
buttonSave.Enabled = false;
groupBoxDataLogger.Enabled = false;
checkBoxCogJobEnable.Enabled = false;
if (mainForm.GetUserAccountLevel(mainForm.CurrentLoggedOnUser) >= 3)
{
groupBoxDataLogger.Enabled = true;
checkBoxCogJobEnable.Enabled = true;
}
// Disable certain items if vision is online
if (mainForm.VisionOnline)
{
checkBoxCogJobEnable.Enabled = false;
}
}
public override void ThreadZeroed(int parentThread)
{
base.ThreadZeroed(parentThread);
AbilityCentralThreadPool centralInst = GetCentralInst();
int[][] variableLinks = centralInst.GetVariableLinks(0, GetNodeId(), GetVariableId("Return from Variable"));
if (variableLinks.Length == 0)
{
return;
}
int[] modifiedReturn = variableLinks[0];
returnTargetInst = centralInst.ReturnRuntimeParameter(modifiedReturn[0], modifiedReturn[1]);
returnTargetInst.RunGenericBasedOnRP <int>(this, parentThread);
threadMap.Remove(parentThread);
}
public void Fetch(RuntimeParameters p_Parameters,
string p_RemoteName,
string p_HostingUrl)
{
FetchOptions options = new FetchOptions {
CredentialsProvider = (url,
usernameFromUrl,
types) =>
new UsernamePasswordCredentials {
Username = p_Parameters.Username, Password = p_Parameters.Password
}
};
var remote = m_Repository.Network.Remotes[p_RemoteName];
s_Logger.Debug($"Remote Url remote: {remote.Url}");
var refSpecs = remote.FetchRefSpecs.Select(x => x.Specification);
Commands.Fetch(m_Repository, remote.Name, refSpecs, options, "Fetching the latest changes.");
}
/*public void CreateAbilityNetworkData() {
* AbilityCentralThreadPool centralPool = new AbilityCentralThreadPool(playerId);
* SignalCentralCreation(centralPool);
* CreateAbility(centralPool, ClientProgram.clientId);
* }*/
public void CreateAbility(AbilityCentralThreadPool threadInst,int pId,int givenPopulatedId = -1)
{
if (givenPopulatedId > -1)
{
AbilitiesManager.aData[pId].playerSpawnedCentrals.ModifyElementAt(givenPopulatedId,threadInst);
}
else
{
givenPopulatedId = AbilitiesManager.aData[pId].InsertSpawnedIntoFreeSpace(threadInst);//AbilityCentralThreadPool.globalCentralList.Add(threadInst);
}
//int nId = AbilityTreeNode.globalList.Add(new AbilityNodeHolder(tId.ToString(), a));
//Variable[][] clonedCopy = CloneRuntimeParams(dataVar);
RuntimeParameters[][] clonedRp = new RuntimeParameters[dataVar.Length][];
int[][][][][] linkMap = new int[1][][][][];
linkMap[0] = new int[dataVar.Length][][][];
for (int i = 0; i < dataVar.Length; i++)
{
clonedRp[i] = new RuntimeParameters[dataVar[i].Length];
linkMap[0][i] = new int[dataVar[i].Length][][];
for (int j = 0; j < dataVar[i].Length; j++)
{
clonedRp[i][j] = dataVar[i][j].field.ReturnNewRuntimeParamCopy();
linkMap[0][i][j] = dataVar[i][j].links;
}
}
//Debug.Log(boolData.OutputValues());
bool[][] clonedBoolValues = boolData.ReturnNewCopy();
threadInst.SetCentralData(pId,givenPopulatedId,clonedRp,generatedLinks,dataType,nodeBranchingData,clonedBoolValues,autoManagedVariables,targettedNodes,nodeNetworkVariables);
//if(startThreads)
// threadInst.StartThreads();
//threadInst.SendVariableNetworkData();
}
