public CraftingAI(Character user)
{
OpenFileDialog openfiledialog = new OpenFileDialog();
openfiledialog.Filter = Resources.CraftingAI_CraftingAI_Crafting_AI_Script____csx____csx;
if (openfiledialog.ShowDialog() == DialogResult.Cancel)
return;
_scriptingObject = new ScriptingObject(user);
_host = new ScriptingHost(_scriptingObject);
_host.ImportNamespace("Chocobot.Utilities.Keyboard");
_host.ImportNamespace("Chocobot.Datatypes");
try
{
_host.ExecuteFile(openfiledialog.FileName);
}
catch (Roslyn.Compilers.CompilationErrorException ex)
{
MessageBox.Show(ex.Diagnostics.ToString(), Resources.CraftingAI_CraftingAI_Scripting_Error, MessageBoxButtons.OK, MessageBoxIcon.Error);
Debug.Print(ex.Diagnostics.ToString());
return;
}
try
{
var res = _host.Execute("Initialize();");
}
catch (Roslyn.Compilers.CompilationErrorException ex)
{
Console.WriteLine("{0}{1}", Environment.NewLine,
ex.Diagnostics);
throw;
}
_valid = true;
}
public override Result Query(string query)
{
MongoDatabase database = GetDatabase();
var host = new ScriptingHost(database) {};
InitializeHost(host);
object data = host.Execute(query);
return new Result
{
Success = true,
Data = data
};
}
public ScriptAI()
: base()
{
IsRanged = true;
Name = "Scripting";
OpenFileDialog openfiledialog = new OpenFileDialog();
openfiledialog.Filter = "Class AI Script (*.csx)|*.csx";
if (openfiledialog.ShowDialog() == DialogResult.Cancel)
return;
_scriptingObject = new ScriptingObject();
_host = new ScriptingHost(_scriptingObject);
_host.ImportNamespace("Chocobot.Utilities.Keyboard");
_host.ImportNamespace("Chocobot.Datatypes");
_host.ImportNamespace("Chocobot.MemoryStructures.Abilities.Recast");
_host.ImportNamespace("Chocobot.MemoryStructures.Abilities.Hotkeys");
_host.ImportNamespace("Chocobot.Utilities.Memory");
_host.ImportNamespace("Chocobot.Utilities.Memory.MemoryFunctions");
_host.ImportNamespace("Chocobot.MemoryStructures.Character");
_host.ImportNamespace("System.DateTime");
_host.ImportNamespace("Chocobot.Datatypes.Global");
try
{
_host.ExecuteFile(openfiledialog.FileName);
}
catch (Roslyn.Compilers.CompilationErrorException ex)
{
MessageBox.Show(ex.Diagnostics.ToString(), "Scripting Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
Debug.Print(ex.Diagnostics.ToString());
return;
}
try
{
var res = _host.Execute("Initialize();");
}
catch (Roslyn.Compilers.CompilationErrorException ex)
{
Console.WriteLine("{0}{1}", Environment.NewLine,
ex.Diagnostics);
throw;
}
IsRanged = _scriptingObject.IsRanged;
_valid = true;
}
public static TResult ExecuteScriptExpression <TResult> (string expressionScriptSourceCode, params object[] scriptParameter)
{
const ScriptLanguageType scriptLanguageType = ScriptLanguageType.Python;
var engine = ScriptingHost.GetScriptEngine(scriptLanguageType);
var scriptSource = engine.CreateScriptSourceFromString(expressionScriptSourceCode, SourceCodeKind.Expression);
var compiledScript = scriptSource.Compile();
var scriptScope = ScriptingHost.GetScriptEngine(scriptLanguageType).CreateScope();
for (int i = 0; i < scriptParameter.Length; i++)
{
scriptScope.SetVariable("p" + i, scriptParameter[i]);
}
return(compiledScript.Execute <TResult> (scriptScope));
}
public void ImportFromAssemblyIntoScriptScope(ScriptScope scriptScope, string assembly, string nameSpace, string symbol)
{
string scriptText = @"
import clr
clr.AddReferenceByPartialName('" + assembly + "')" +
@"
from " + nameSpace + " import " + symbol;
const ScriptLanguageType scriptLanguageType = ScriptLanguageType.Python;
var engine = ScriptingHost.GetScriptEngine(scriptLanguageType);
var scriptSource = engine.CreateScriptSourceFromString(scriptText, SourceCodeKind.Statements);
scriptSource.Execute(scriptScope);
}
internal void Reset()
{
// CSharp App
if (appAssembly != null && methodReset != null)
{
methodReset.Invoke(assembly, null);
}
// Python, Ruby, Javascript
else if (hgScriptingHost != null)
{
hgScriptingHost.Reset();
hgScriptingHost = null;
}
}
public bool Load()
{
Unload();
if (Homegenie == null)
{
return(false);
}
scriptEngine = new Engine();
hgScriptingHost = new ScriptingHost();
hgScriptingHost.SetHost(Homegenie, ProgramBlock.Address);
scriptEngine.SetValue("hg", hgScriptingHost);
return(true);
}
public bool Load()
{
if (homegenie == null)
{
return(false);
}
if (hgScriptingHost != null)
{
this.Reset();
hgScriptingHost = null;
}
hgScriptingHost = new ScriptingHost();
hgScriptingHost.SetHost(homegenie, programBlock.Address);
return(true);
}
public object GetAttributeProxy(Object proxied, string attributeName)
{
var key = new Tuple <Type, string> (proxied.GetType(), attributeName);
AttributeProxyCached attributeProxyCached;
if (!_proxiedTypeToAttributeProxyCache.TryGetValue(key, out attributeProxyCached))
{
object proxy = GetProxy(proxied);
var attributeProxy = ScriptingHost.GetScriptEngine(ScriptLanguageType.Python).Operations.GetMember(proxy, attributeName);
attributeProxyCached = new AttributeProxyCached(proxy, attributeProxy);
_proxiedTypeToAttributeProxyCache[key] = attributeProxyCached;
}
((IProxy)attributeProxyCached.Proxy).SetProxied(proxied);
return(attributeProxyCached.AttributeProxy);
}
private void SetupScriptingScope()
{
hgScriptingHost = new ScriptingHost();
hgScriptingHost.SetHost(homegenie, this.Address);
if (scriptEngine.GetType() == typeof(ScriptEngine))
{
// IronPyton and IronRuby engines
ScriptEngine currentEngine = (scriptEngine as ScriptEngine);
dynamic scope = scriptScope = currentEngine.CreateScope();
scope.hg = hgScriptingHost;
}
else if (scriptEngine.GetType() == typeof(Jint.Engine))
{
// Jint Javascript engine
Jint.Engine javascriptEngine = (scriptEngine as Jint.Engine);
javascriptEngine.SetValue("hg", hgScriptingHost);
}
}
public bool Load()
{
if (HomeGenie == null)
{
return(false);
}
script = new WizardScript(ProgramBlock);
if (hgScriptingHost != null)
{
this.Reset();
hgScriptingHost = null;
}
hgScriptingHost = new ScriptingHost();
hgScriptingHost.SetHost(HomeGenie, ProgramBlock.Address);
return(true);
}
public bool Load()
{
Unload();
if (homegenie == null)
{
return(false);
}
scriptEngine = Ruby.CreateEngine();
hgScriptingHost = new ScriptingHost();
hgScriptingHost.SetHost(homegenie, programBlock.Address);
dynamic scope = scriptScope = scriptEngine.CreateScope();
scope.hg = hgScriptingHost;
return(true);
}
public void ScriptingHost_ValidBooleanVariableTest()
{
ScriptingHost host = new ScriptingHost();
Assert.IsNotNull(host);
bool[] expectedValues = VariableValueTest.ValidBooleanValues;
for (int i = 0; i < expectedValues.Length; i++)
{
StateVariable sv = new StateVariable()
{
Name = $"test{i}", Type = VariableValueType.Boolean
};
host.Create(sv);
VariableValue defaultValue = host.Get(sv);
Assert.AreEqual(VariableValueType.Boolean, defaultValue.Type);
Assert.AreEqual(default, defaultValue.BooleanValue);
public void Unload()
{
Reset();
hgScriptingHost = null;
}
protected object Filter(IEnumerable collection, Type type, NameValueCollection param)
{
object data = null;
if (param["$filter"] != null)
{
var casted = Cast(collection, type);
data = Filter(casted, type, param);
}
else
{
string finalQuery = "";
if (param["$query"] != null)
{
finalQuery = string.Format("{0} " + param["$query"] + "{1}",
"(from " + type.Name + " row in Rows where ",
" select row)");
}
else
{
finalQuery = "(from " + type.Name + " row in Rows select row)";
}
if (param["$skip"] != null)
{
int skip;
int.TryParse(param["$skip"], out skip);
finalQuery += ".Skip(" + skip + ")";
}
if (param["$take"] != null)
{
int take;
int.TryParse(param["$take"], out take);
finalQuery += ".Take(" + take + ")";
}
var host = new ScriptingHost { Rows = collection };
InitializeHost(host);
host.AddReference(type.Assembly);
host.ImportNamespace(type.Namespace);
data = host.Execute(finalQuery);
}
return data;
}
public static ReadOnlyDictionary <ScriptLanguageType, ScriptEngine> FindScriptEngines(this ScriptingHost scriptingHost)
{
return((ReadOnlyDictionary <ScriptLanguageType, ScriptEngine>)
PrivateInvoke.InvokeNonPublicMethod(scriptingHost, "FindScriptEngines"));
}
public static ScriptEngine GetEngine(this ScriptingHost scriptingHost, ScriptLanguageType languageType)
{
return((ScriptEngine)PrivateInvoke.InvokeNonPublicMethod(scriptingHost, "GetEngine", languageType));
}
public void SetScriptingHost(ScriptingHost scriptingHost)
{
this.scriptingHost = scriptingHost;
}
public void Unload()
{
Reset();
scriptEngine = null;
hgScriptingHost = null;
}
public void ScriptingHost_NewTest()
{
ScriptingHost host = new ScriptingHost();
Assert.IsNotNull(host);
}
internal ScriptingHostPrivateData(ScriptingHost host)
{
ScriptingHost = host;
}
public void GetEngine_Static()
{
var pythonEngine = ScriptingHost.GetScriptEngine(ScriptLanguageType.Python);
Assert.That(pythonEngine, Is.Not.Null);
}
public void GetEngine_Static_Fails()
{
ScriptingHost.GetScriptEngine(ScriptLanguageType.None);
}
public static ScriptRuntime GetScriptRuntime(this ScriptingHost scriptingHost)
{
return((ScriptRuntime)PrivateInvoke.InvokeNonPublicMethod(scriptingHost, "GetScriptRuntime"));
}
public void GetEngine_Fails()
{
ScriptingHost scriptingHost = CreateScriptingHost();
scriptingHost.GetEngine(ScriptLanguageType.None);
}
protected void InitializeHost(ScriptingHost host)
{
ITypeResolver resolver = GetResolver();
Assembly[] rs = resolver.GetReferences();
string[] ns = resolver.GetNamespaces();
if (rs != null)
foreach (Assembly r in rs)
host.AddReference(r);
if (ns != null)
foreach (string n in ns)
host.ImportNamespace(n);
}
