public void Set_LogicVariableShouldReturnTrue()
{
var lv = new LogicVariable {
Value = true
};
Assert.True(lv.Value);
}
public void AddVariable_ShouldAddName()
{
CombinatorialCircuit c = new CombinatorialCircuit();
LogicVariable a = new LogicVariable {
Name = "x1"
};
bool result = c.AddVariable(a);
Assert.True(result, "Should add variable name.");
}
public bool AddVariable(LogicVariable newLv)
{
LogicVariable lv;
if (_lv.TryGetValue(newLv.Name, out lv))
{
return(false);
}
_lv.Add(newLv.Name, newLv);
return(true);
}
public void GetLogicVariableByName_ShouldGetSameLogicVariable()
{
// We can use 'var' as an implicit type letting the compiler
// determines and assign the most appropriate type
var c = new CombinatorialCircuit();
var a = new LogicVariable {
Name = "x1"
};
c.AddVariable(a);
Assert.Same(a, c.GetLogicVariableByName("x1"));
}
void DoNextAction()
{
var actionVar = new LogicVariable("Action");
var beforeBytes = GC.GetTotalMemory(false);
var action = this.SolveFor(actionVar, new Structure(SNextAction, actionVar));
var allocBytes = GC.GetTotalMemory(false) - beforeBytes;
if (allocBytes > 0)
{
DecisionCycleAlloc = (int)allocBytes;
}
InitiateAction(action);
}
private void MouseSelectionChanged(GameObject newSelection)
{
MouseSelection = newSelection;
if (MouseSelection != null)
{
captionStyle.normal.textColor = Color.white;
var cap = new LogicVariable("Caption");
caption =
new GUIContent(
(string)KnowledgeBase.Global.SolveFor(cap, new Structure("caption", MouseSelection, cap), this));
captionSize = captionStyle.CalcSize(caption);
}
TryCompletionIfCompleteWord();
}
public void AddVariable_ShouldFailAddDuplicateName()
{
CombinatorialCircuit c = new CombinatorialCircuit();
LogicVariable a = new LogicVariable {
Name = "x2"
};
LogicVariable b = new LogicVariable {
Name = "x2"
};
c.AddVariable(a);
bool result = c.AddVariable(b);
Assert.False(result, "Should fail add duplicate variable name.");
}
public object CheckPlan(object head)
{
var full = new LogicVariable("Full");
try
{
myKB.SolveFor(full, new Structure("check_plan", head, full), this);
}
catch (System.Exception)
{
return(false);
}
return(full);
}
public object Activate(object name)
{
LogicVariable conditions = new LogicVariable("Conditions");
try
{
myKB.SolveFor(conditions, new Structure("activate", name, conditions), this);
}
catch (System.Exception ex)
{
return(false);
}
return(conditions);
}
public object Use(object name)
{
LogicVariable plan = new LogicVariable("Plan");
try
{
myKB.SolveFor(plan, new Structure("use", name, plan), this);
}
catch (System.Exception ex)
{
return(false);
}
return(plan);
}
public void Execute(LogicExecuteMethodInformation executeMethodInformation, LogicVariable variable)
{
object value;
if (this.abj != null)
{
value = this.abj.Execute(executeMethodInformation);
}
else
{
value = null;
}
FieldInfo field = executeMethodInformation.LogicClassType.GetField(variable.VariableName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
field.SetValue(executeMethodInformation.LogicEntityObject, value);
}
public override object Execute(LogicExecuteMethodInformation executeMethodInformation)
{
if (string.IsNullOrEmpty(this.abm))
{
Log.Error("Get Variable: variableName not defined");
return(null);
}
object obj = null;
LogicVariable variableByName = base.ParentMethod.ParentClass.GetVariableByName(this.abm);
if (variableByName != null)
{
if (base.DotPathAction != null && base.DotPathAction is LogicAssignVariableAction)
{
((LogicAssignVariableAction)base.DotPathAction).Execute(executeMethodInformation, variableByName);
return(null);
}
FieldInfo field = executeMethodInformation.LogicClassType.GetField(variableByName.VariableName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
obj = field.GetValue(executeMethodInformation.LogicEntityObject);
}
LogicLocalVariable logicLocalVariable = null;
if (variableByName == null)
{
logicLocalVariable = executeMethodInformation.GetLocalVariable(this.abm);
if (logicLocalVariable != null)
{
if (base.DotPathAction != null && base.DotPathAction is LogicAssignVariableAction)
{
((LogicAssignVariableAction)base.DotPathAction).Execute(executeMethodInformation, logicLocalVariable);
return(null);
}
obj = logicLocalVariable.Value;
}
}
if (variableByName == null && logicLocalVariable == null)
{
Log.Error("Get Variable: variable not exists \"{0}\"", this.abm);
return(null);
}
if (base.DotPathAction != null)
{
obj = base.DotPathAction.Execute(executeMethodInformation, obj);
}
return(obj);
}
PieMenu MakeMenu(GameObject selection)
{
var tags = new List <string>();
var actions = new List <object>();
var stringVar = new LogicVariable("Tag");
var actionVar = new LogicVariable("Action");
var goal = new Structure("menu_item", selection, stringVar, actionVar);
// ReSharper disable once UnusedVariable
#pragma warning disable 168
foreach (var ignore in gameObject.KnowledgeBase().Prove(goal))
#pragma warning restore 168
{
tags.Add((string)stringVar.Value);
actions.Add(Term.CopyInstantiation(actionVar));
}
return(new PieMenu(tags, actions, MenuGUIStyle, 50, SimController.GreyOutTexture));
}
public override Type GetReturnType()
{
if (!string.IsNullOrEmpty(this.VariableName))
{
LogicVariable variableByName = base.ParentMethod.ParentClass.GetVariableByName(this.VariableName);
if (variableByName != null)
{
return(variableByName.VariableType);
}
}
List <LogicLocalVariable> accessedLocalVariables = base.ParentMethod.GetAccessedLocalVariables(this);
foreach (LogicLocalVariable current in accessedLocalVariables)
{
if (current.Name == this.VariableName)
{
return(current.Type);
}
}
return(null);
}
void Init()
{
int index = 0;
string oper = "";
while (index < m_Expression.Length)
{
char c = m_Expression[index];
++index;
if (c == '=')
{
oper += c;
if (oper == "==" || oper == "!=" || oper == ">=" || oper == "<=")
{
m_Operation = oper;
}
}
else if (c == '!' || c == '>' || c == '<')
{
oper += c;
m_Operation = oper;
}
else
{
oper = "";
}
}
if (string.IsNullOrEmpty(m_Operation))
{
throw new Exception("m_Operation error");
}
string[] e = m_Expression.Split(new string[] { m_Operation }, StringSplitOptions.RemoveEmptyEntries);
if (e.Length != 2)
{
throw new Exception("vars error");
}
m_Left = new LogicVariable(e[0]);
m_Right = new LogicVariable(e[1]);
}
private void TryCompletion()
{
var completionVar = new LogicVariable("Output");
var dialogActVar = new LogicVariable("DialogAct");
bool completionSuccess = false;
try
{
completionSuccess = this.IsTrue("input_completion", this.input, completionVar, dialogActVar);
}
catch (InferenceStepsExceededException e)
{
Debug.LogError("Completion took too many steps for input: " + this.input);
Debug.LogException(e);
}
if (completionSuccess)
{
this.completion = (string)completionVar.Value;
this.dialogAct = Term.CopyInstantiation(dialogActVar.Value);
if (this.IsTrue("well_formed_dialog_act", this.dialogAct))
{
this.formatted = this.completion == "" ?
string.Format("<b><color=lime>{0}</color></b>", this.input)
: string.Format("<color=lime>{0}{1}<i>{2}</i></color>",
this.input,
(this.input.EndsWith(" ") || this.input.EndsWith("'") ||
!char.IsLetterOrDigit(this.completion[0]))
? "" : " ",
this.completion);
var da = this.dialogAct as Structure;
if (da != null && da.Arity > 1)
{
var a = da.Argument <GameObject>(1);
this.commentary = string.Format("{0} to {1}\n{2}", da.Functor, (a == this) ? "myself" : a.name,
ISOPrologWriter.WriteToString(dialogActVar.Value));
}
else
{
this.commentary = ISOPrologWriter.WriteToString(dialogActVar.Value);
}
}
else
{
// Input is grammatical but not well formed.
this.formatted = this.completion == "" ?
string.Format("<b><color=yellow>{0}</color></b>", this.input)
: string.Format("<color=yellow>{0}{1}</color><color=grey><i>{2}</i></color>",
this.input,
(this.input.EndsWith(" ") || !char.IsLetterOrDigit(this.completion[0])) ? "" : " ",
this.completion);
if (this.completion == "")
{
this.commentary = string.Format(
"This input is grammatical, but doesn't make sense to me\n{0}",
ISOPrologWriter.WriteToString(dialogActVar.Value));
}
else
{
this.commentary = "This is grammatical but nonsensical\n" + ISOPrologWriter.WriteToString(dialogActVar.Value);
}
}
}
else
{
this.formatted = string.Format("<color=red>{0}</color>", this.input);
this.commentary = "Sorry; I don't understand any sentences beginning with those words.";
}
}
private void TryCompletion()
{
// Update the mouse selection, so Prolog can get at it.
mouseSelectionELNode.StoreExclusive(MouseSelection, true);
var completionVar = new LogicVariable("Output");
var dialogActVar = new LogicVariable("DialogAct");
bool completionSuccess = false;
try
{
completionSuccess = this.IsTrue("input_completion", input, completionVar, dialogActVar);
}
catch (InferenceStepsExceededException e)
{
Debug.LogError("Completion took too many steps for input: " + input);
Debug.LogException(e);
}
if (completionSuccess)
{
completion = (string)completionVar.Value;
dialogAct = Term.CopyInstantiation(dialogActVar.Value);
if (this.IsTrue("well_formed_dialog_act", dialogAct))
{
formatted = completion == "" ?
string.Format("<b><color=lime>{0}</color></b>", input)
: string.Format("<color=lime>{0}{1}<i>{2}</i></color>",
input,
(input.EndsWith(" ") || input.EndsWith("'") ||
!char.IsLetterOrDigit(completion[0]))
? "" : " ",
completion);
var da = dialogAct as Structure;
if (da != null && da.Arity > 1)
{
var a = da.Argument <GameObject>(1);
var addressee = (a == gameObject) ? "myself" : a.name;
commentary = string.Format("{0} to {1}\n{2}", da.Functor, addressee,
ISOPrologWriter.WriteToString(dialogActVar.Value));
formatted = string.Format("{1} (speaking to {0})", addressee, formatted);
}
else
{
commentary = ISOPrologWriter.WriteToString(dialogActVar.Value);
}
}
else
{
// Input is grammatical but not well formed.
formatted = completion == "" ?
string.Format("<b><color=yellow>{0}</color></b>", input)
: string.Format("<color=yellow>{0}{1}</color><color=grey><i>{2}</i></color>",
input,
(input.EndsWith(" ") || !char.IsLetterOrDigit(completion[0])) ? "" : " ",
completion);
if (completion == "")
{
commentary = string.Format(
"This input is grammatical, but doesn't make sense to me\n{0}",
ISOPrologWriter.WriteToString(dialogActVar.Value));
}
else
{
commentary = "This is grammatical but nonsensical\n" + ISOPrologWriter.WriteToString(dialogActVar.Value);
}
}
}
else
{
var lastWordOfInput = LastWordOfInput;
if (lastWordOfInput != "" && Prolog.Prolog.IsPrefixOfDistinctLexicalItem(lastWordOfInput))
{
FormatInputWithoutColorCoding();
}
else
{
FormatRejectionOfInput();
}
}
}
public abstract bool BindsVar(LogicVariable v);
private static void Main(string[] args)
{
// NOTE: No error handling etc. is included here, this sample is just intended to give you a starting point on
// handling zenon Logic projects via code,
// IMPORTANT: To avoid side effects, you should make sure that the Logic workbench is not running,
// which is not shown here.
// This sample accesses zenon via COM, therefore we need to connect first.
var zenonEditor = Marshal.GetActiveObject(ZenonRuntimeComObjectName) as zenOn.ApplicationED;
if (zenonEditor == null)
{
Console.WriteLine("Cannot connect to an instance of zenon Editor.");
return;
}
// The active zenon editor project is used for our sample.
var zenonProject = zenonEditor.MyWorkspace.ActiveDocument;
if (zenonProject == null)
{
Console.WriteLine("No active instance of a zenon Editor project can be received.");
return;
}
// NOTE: For this example, you need a reference to zenon.Interop.dll in your .csproj.
// We added it from version 7.60 to a binaries folder.
//
// You can use alternative approaches to the one which is shown here, i.e.:
// - modifying the project as pure XML
// Required: References to zenonApi.Core and zenonApi.Logic.
// Advantage: No dependency on Windows or zenon.
// Disadvantage: If you want to import the object model to Logic, you need to do this on your own.
// - modifying the project via a COM reference to zenon, as done in this example
// Required: Reference to zenon.Interop.dll, references to zenonApi.Core, zenonApi.Logic and zenonApi.Zenon
// Advantage: Easy to import and modify Logic projects from within a zenon context.
// Disadvantage: Can only be done with a running zenon Editor instance on Windows
// - modifying the project not via the Add-In framework
// Required: Reference to Scada.AddIn.Contracts, zenonApi.Core, zenonApi.Logic, zenonApi.Zenon
// Advantage: Same as for COM
// Disadvantage: Same as for COM
// - Just create projects and do basic modifications without any of our APIs
// Required: -
// Advantage: No dependencies, except K5B.exe and/or K5Prp.dll
// Disadvantage: Just XML, no typed object model, hard to modify/maintain, etc.
// What you choose simply depends on what you are developing and using.
// The easiest way might be to work with the provided APIs we use here for COM and Add-In.
// If you use the Add-In Framework, use "new zenonApi.Zenon.Zenon(zenonProject)
var wrapper = new zenonApi.Zenon.ZenonCom(zenonProject);
// We want to modify or create a Logic project named "Sample":
var lazyLogicProjects = wrapper.LazyLogicProjects;
var sampleProjectToBeEdited = lazyLogicProjects.FirstOrDefault(x => x.ProjectName == "Sample")?.Value;
if (sampleProjectToBeEdited == null)
{
// "Sample" does not exist, we need to create it with the following.
// All changes you make in the API will only take affect, after you call ImportLogicProjectsIntoZenon
// (see the end of this file)
sampleProjectToBeEdited = new LogicProject("Sample");
lazyLogicProjects.Add(new LazyLogicProject(sampleProjectToBeEdited));
}
// Access the logic options etc. via a object model. The following shows some examples.
sampleProjectToBeEdited.Settings.TriggerTime.CycleTime = 10000;
sampleProjectToBeEdited.Settings.CompilerSettings.CompilerOptions["warniserr"] = "OFF";
// Get the first global variable group ("(GLOBAL)" and "(RETAIN)" always exist).
var variableGroup = sampleProjectToBeEdited.GlobalVariables.VariableGroups.FirstOrDefault();
// The appropriate group can also be accessed directly like this:
variableGroup = sampleProjectToBeEdited.GlobalVariables[LogicVariableKind.Global];
// Sample for creating some string variables in our "Sample" project:
for (int i = 0; i < 10; i++)
{
var variableSample = new LogicVariable()
{
InitialValue = "5",
MaxStringLength = "255",
Type = "STRING",
Name = "MyVariable" + i,
};
variableSample.VariableInfos.Add(new LogicVariableInfo()
{
// Set to be visible in zenon (SYB Flag)
Data = "<syb>",
Type = LogicVariableInformationTypeKind.Embed
});
variableSample.VariableInfos.Add(new LogicVariableInfo()
{
Data = "STRATON",
Type = LogicVariableInformationTypeKind.Profile
});
variableGroup.Variables.Add(variableSample);
}
// Get the first folder of your application tree in Logic and rename it
LogicFolder folder = sampleProjectToBeEdited.ApplicationTree.Folders.FirstOrDefault();
if (folder == null)
{
// Does not exist, create it instead.
folder = new LogicFolder("RenamedTestFolder");
sampleProjectToBeEdited.ApplicationTree.Folders.Add(folder);
}
// Renaming is possible.
folder.Name = "RenamedTestFolder";
// Same for the first program:
LogicProgram program = folder.Programs.FirstOrDefault();
if (program == null)
{
program = new LogicProgram("RenamedTestProgram");
folder.Programs.Add(program);
}
program.Name = "RenamedMyProgram";
// Modify the source code of a program:
program.SourceCode += "\n// Some Comment";
// Navigate back to the application tree when only having the program (useful when working with multiple logic
// projects at once):
var folderAgain = program.Parent;
// Change the cycle timing and other project settings
sampleProjectToBeEdited.Settings.TriggerTime.CycleTime = 12345;
sampleProjectToBeEdited.Settings.CompilerSettings.CompilerOptions["warniserr"] = "OFF";
// Modify variables (if it exists)
var variable = program.VariableGroups.FirstOrDefault()?.Variables.FirstOrDefault();
if (variable != null)
{
variable.Name = "RenamedVariable";
variable.Attributes.In = true;
variable.Attributes.Out = true;
variable.VariableInfos.Add(new LogicVariableInfo()
{
Type = LogicVariableInformationTypeKind.Embed, Data = "<syb>"
});
}
// Remove a folder if it exists
sampleProjectToBeEdited.ApplicationTree.Folders.FirstOrDefault(x => x.Name == "Signals")?.Remove();
// Sample for exporting a project object model to a file:
string sampleFile = $@"C:\Users\{Environment.UserName}\Desktop\DemoProjectModified.xml";
sampleProjectToBeEdited.ExportAsFile(sampleFile, Encoding.GetEncoding("iso-8859-1"));
// Sample for reading a project object model from a file:
var projectFromXmlFile = LogicProject.Import(XElement.Load(sampleFile));
// Sample for convert the project object model to XElements and save it manually to the same file
XElement modifiedProject = sampleProjectToBeEdited.ExportAsXElement();
XDocument document = new XDocument
{
Declaration = new XDeclaration("1.0", "iso-8859-1", "yes")
};
document.Add(modifiedProject);
using (XmlTextWriter writer = new XmlTextWriter(
$@"C:\Users\{Environment.UserName}\Desktop\DemoProjectModified.xml",
Encoding.GetEncoding("iso-8859-1")))
{
writer.Indentation = 3;
writer.Formatting = Formatting.Indented;
document.Save(writer);
}
// Import and commit logic projects with the changes we made:
wrapper.ImportLogicProjectsIntoZenon();
// For zenon version 10 or higher, additional import options are available, e.g.:
// wrapper.ImportLogicProjectsIntoZenon(true, ImportOptions.ReCreateVariables | ImportOptions.ApplyOnlineSettings);
wrapper.Dispose();
}
public abstract bool BindsVar(LogicVariable v);
private void InitiateAction(object action)
{
if (action == null)
{
return;
}
var actionCopy = Term.CopyInstantiation(action);
ELNode.Store(motorRoot / SLastAction % actionCopy);
var structure = action as Structure;
if (structure != null)
{
switch (structure.Functor.Name)
{
case "face":
Face(structure.Argument <GameObject>(0));
break;
case "say":
// Say a fixed string
Say(structure.Argument <string>(0), gameObject);
break;
case "cons":
// It's a list of actions to initiate.
InitiateAction(structure.Argument(0));
InitiateAction(structure.Argument(1));
break;
case "pause":
pauseUntil = Time.time + Convert.ToSingle(structure.Argument(0));
break;
case "pickup":
{
var patient = structure.Argument <GameObject>(0);
if (patient == gameObject)
{
throw new InvalidOperationException(name + ": tried to pickup() self!");
}
if (patient == gameObject)
{
return;
}
if (patient == null)
{
throw new NullReferenceException("Argument to pickup is not a gameobject");
}
var physob = patient.GetComponent <PhysicalObject>();
if (physob == null)
{
throw new NullReferenceException("Argument to pickup is not a physical object.");
}
physob.MoveTo(gameObject);
break;
}
case "ingest":
{
var patient = structure.Argument <GameObject>(0);
if (patient == null)
{
throw new NullReferenceException("Argument to ingest is not a gameobject");
}
var physob = patient.GetComponent <PhysicalObject>();
if (physob == null)
{
throw new NullReferenceException("Argument to ingest is not a physical object.");
}
physob.Destroy();
// TODO: FIX LOCATION UPDATE SO WE DON'T NEED TO KLUGE THIS
locationRoot.DeleteKey(patient);
var propinfo = patient.GetComponent <PropInfo>();
if (propinfo != null)
{
if (propinfo.IsFood)
{
physiologicalStates.DeleteKey(Symbol.Intern("hungry"));
}
if (propinfo.IsBeverage)
{
physiologicalStates.DeleteKey(Symbol.Intern("thirsty"));
}
}
break;
}
case "putdown":
{
var patient = structure.Argument <GameObject>(0);
if (patient == gameObject)
{
throw new InvalidOperationException(name + ": tried to putdown() self!");
}
if (patient == null)
{
throw new NullReferenceException("Argument to putdown is not a gameobject");
}
var physob = patient.GetComponent <PhysicalObject>();
if (physob == null)
{
throw new NullReferenceException("Argument to putdown is not a physical object.");
}
var dest = structure.Argument <GameObject>(1);
if (dest == null)
{
throw new NullReferenceException("Argument to putdown is not a gameobject");
}
physob.MoveTo(dest);
break;
}
case "flash":
{
flashColorA = structure.Argument <Color>(0);
flashColorB = structure.Argument <Color>(1);
flashPeriod = Convert.ToSingle(structure.Argument(2));
flashStartTime = Time.time;
flashEndTime = flashStartTime + Convert.ToSingle(structure.Argument(3));
break;
}
case "get_in":
GetIn(structure.Argument <GameObject>(0));
break;
case "dismount":
Dismount();
break;
case "end_game":
Application.Quit();
break;
default:
// Assume it's dialog
this.IsTrue("log_dialog_act", structure);
GameObject thisAddressee =
((structure.Arity >= 2) ?
structure.Argument(1) as GameObject
: gameObject) ?? gameObject;
var talkingToSelf = thisAddressee == gameObject;
if (!talkingToSelf || ShowMentalMonologue)
{
var textVar = new LogicVariable("DialogText");
object text = null;
try
{
text = gameObject.SolveFor(textVar, "generate_text", structure, textVar);
}
catch (Exception e)
{
Debug.LogError(string.Format("Exception while generating text for {0}", gameObject.name));
Debug.LogException(e);
}
var textString = text as string;
if (textString == null)
{
throw new Exception(
"generate_text returned " + ISOPrologWriter.WriteToString(text) + " for "
+ ISOPrologWriter.WriteToString(structure));
}
var talkingToPlayer = structure.Arity >= 2 &&
ReferenceEquals(structure.Argument(1), playerSymbol);
SetSpeechTimeout(textString);
if (talkingToPlayer)
// Character is talking to zhimself
{
if (nlPrompt != null)
{
nlPrompt.OutputToPlayer(textString);
}
else
{
Say(string.Format("({0})", textString), thisAddressee);
}
}
else
{
Say(textString, thisAddressee);
}
if (!talkingToPlayer && !talkingToSelf)
{
// Tell the other characters
foreach (var node in socialSpace.Children)
{
var character = (GameObject)(node.Key);
if (character != gameObject)
{
character.QueueEvent((Structure)Term.CopyInstantiation(structure));
}
}
// TODO: fix it so that when characters appear, the system computes their social
// spaces from scratch. Then we won't need this kluge.
if (!socialSpace.ContainsKey(thisAddressee))
{
thisAddressee.QueueEvent((Structure)Term.CopyInstantiation(structure));
}
}
}
break;
}
if (structure.Functor.Name != "pause")
{
// Report back to the character that the action has occurred.
QueueEvent(structure);
}
}
else
{
throw new InvalidOperationException("Unknown action: " + ISOPrologWriter.WriteToString(action));
}
}
