public void Handle(short id)
{
GameData.CurrentSimpleEncounter = new SimpleEncounter(id);
GameData.state = AdventureGameState.SimpleEncounter;
var data = GameData.CurrentSimpleEncounter.Data;
// how to tell if one is not used??
s1.text = data.OptionTexts[0];
s2.text = data.OptionTexts[1];
s3.text = data.OptionTexts[2];
s4.text = data.OptionTexts[3];
if (data.CanBackout == 0)
{
exitBtn.gameObject.SetActive(false);
}
else
{
exitBtn.gameObject.SetActive(true);
}
scriptHandler = null;
simpleEncounterGo.SetActive(true);
adventureManager.textHandler.SetText(data.Prompt);
// play sound
// If you place - 4 as the Result # for option 1, it will branch directly to Result #4 and skip giving the player any options.
// This will let you do some preliminary stuff prior to any choices being offered to the player.
}
public string ReportOptions(Report report)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("===============================================================================");
sb.AppendLine("[Global scope options]");
sb.AppendLine(ArgsOnlyHandler.Report());
sb.AppendLine(DebugHandler.Report());
sb.AppendLine(InitFileHandler.Report());
sb.AppendLine(ScriptHandler.Report());
sb.AppendLine(TraceHandler.Report());
sb.AppendLine(VerboseHandler.Report());
sb.AppendLine(VerifyHandler.Report());
sb.AppendLine(VerifyMemoryHandler.Report());
sb.AppendLine("[Session scope options]");
sb.AppendLine(report.Session.ReportOptions());
sb.AppendLine("[Report scope options]");
sb.AppendLine(report.ReportOptions());
sb.AppendLine("===============================================================================");
return(sb.ToString());
}
protected override async void HandleSwitch(Theme newTheme, SwitchEventArgs e)
{
string oldTheme = Enum.GetName(typeof(Theme), currentComponentTheme);
Task switchTask = Task.Run(() =>
{
if (newTheme == Theme.Light)
{
Settings.Component.Scripts.ForEach(s =>
{
if (s.AllowedSources.Contains(SwitchSource.Any) || s.AllowedSources.Contains(e.Source))
{
ScriptHandler.Launch(s.Name, s.Command, s.ArgsLight, s.TimeoutMillis, s.WorkingDirectory);
}
});
currentComponentTheme = Theme.Light;
}
else
{
Settings.Component.Scripts.ForEach(s =>
{
if (s.AllowedSources.Contains(SwitchSource.Any) || s.AllowedSources.Contains(e.Source))
{
ScriptHandler.Launch(s.Name, s.Command, s.ArgsDark, s.TimeoutMillis, s.WorkingDirectory);
}
});
currentComponentTheme = Theme.Dark;
}
});
await switchTask;
Logger.Info($"update info - previous: {oldTheme}, now: {Enum.GetName(typeof(Theme), currentComponentTheme)}");
}
protected static void Test5()
{
string code = "CALLO(\"HardwareController\", \"MoveTo\", \"X\", 8000000, 10000000);";
code += "CALLC(\"System.Threading.Thread\", \"Sleep\", 10);";
code += "CALLO(\"HardwareController\", \"MoveTo\", \"X\", 1000000, 10000000);";
code += "CALLC(\"System.Threading.Thread\", \"Sleep\", 10);";
int num = 0;
while (true)
{
while (ScriptHandler.State_1 != ScriptThreadState.Waiting)
{
Thread.Sleep(1000);
}
try
{
Console.WriteLine("------------------------------------------------------------\nRun number: {0}", ++num);
ScriptHandler.SetCodeThread1(code);
}
catch
{
Console.WriteLine("Error");
}
Thread.Sleep(10);
}
}
private void TFPauseBtn_Click(object sender, RoutedEventArgs e)
{
if (Data.TFPauseEnabled)
{
ScriptHandler.PauseThread2();
}
}
private void TFRunBtn_Click(object sender, RoutedEventArgs e)
{
if (Data.TFRunEnabled)
{
string code = Data.TextFieldCode;
ScriptHandler.SetCodeThread2(code);
List <string> s = Data.CodeTextFieldItems;
if (s == null)
{
s = new List <string>();
}
s.Reverse();
if (s.Count == 0)
{
s.Add(code);
}
else
{
s.RemoveAll(x => x == code);
s.Add(code);
}
while (s.Count > 20)
{
s.RemoveAt(0);
}
s.Reverse();
Data.CodeTextFieldItems = new List <string>(s);
s.Clear();
}
}
public async Task ExecuteCodeTest()
{
var scriptHandler = new ScriptHandler();
List <ScriptHandler.ScriptResult> results = new List <ScriptHandler.ScriptResult>();
scriptHandler.ScriptResultReceived += (sender, args) =>
{
results.Add(args);
};
var initSucceeded = await scriptHandler.InitScript();
Assert.True(initSucceeded);
var codeSucceeded = await scriptHandler.ExecuteCode("1 + 1");
Assert.True(codeSucceeded);
var result = results.FirstOrDefault();
Assert.False(result.IsError);
Assert.False(result.IsCancelled);
Assert.Equal("2", result.Result);
Assert.Equal(2, result.ReturnedValue);
}
private void InitializeScriptHandler()
{
_scriptHandler = new ScriptHandler();
_scriptHandler.ScriptActionRaised += ScriptHandlerOnScriptActionRaised;
_scriptHandler.Delay = TimeSpan.FromMilliseconds(-300);
_scriptHandler.SetTimesource(VideoPlayer.TimeSource);
}
public void initalize(MemoryProcess process)
{
this.process = process;
keyHandler = new KeyHandler(this.process);
routeHandler = new RouteHandler(this.process, this.keyHandler);
scriptHandler = new ScriptHandler(this.process, this.keyHandler, this.routeHandler);
}
/**
* Notice that automatic compression doesn't work!
*/
protected void Page_Load(object sender, EventArgs e)
{
if (directive == "compile")
{
_mode = CompositeScriptMode.COMPILE;
}
else if (CookieHandler.Get("mode") == "develop")
{
_mode = CompositeScriptMode.DEVELOP;
}
else
{
_mode = CompositeScriptMode.OPERATE;
}
string folderPath = Path.Combine(HttpContext.Current.Request.PhysicalApplicationPath, "Composite");
switch (type)
{
case "top":
_defaultscripts = ScriptHandler.GetTopScripts(_mode, folderPath);
break;
case "sub":
_defaultscripts = ScriptHandler.GetSubScripts(_mode, folderPath);
break;
}
}
public PythonEngine(IScriptable callback)
{
_callback = callback;
_scriptHandler = new ScriptHandler(_callback);
_engines.Add(callback, this);
}
public ReplWindow()
{
InitializeComponent();
_scriptHandler = new ScriptHandler(func => Dispatcher.InvokeAsync(func).Task)
.AddGlobals
(
("CurrentWindow", this)
)
.AddReferences
(
Assembly.GetExecutingAssembly(),
includeReferencedAssemblies: true
)
.AddUsings
(
"CSharpReplLib.WpfSample",
"System",
"System.Collections.Generic",
"System.Linq",
"System.Reflection",
"System.Windows",
"System.Windows.Documents",
"System.Windows.Input",
"System.Windows.Media"
);
_scriptHandler.ScriptResultReceived += ScriptHandler_ScriptResultReceived;
_scriptHandler.ScriptExecuted += ScriptHandler_ScriptExecuted;
Task.Run(() => _scriptHandler.InitScript());
}
public void Open(ScriptHandler scriptHandler)
{
if (_tempFolder != null && _tempFolder.Exists)
{
_tempFolder.Delete();
}
_scriptHandler = scriptHandler;
_tempFolder = new DirectoryInfo(Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()));
_tempFolder.Create();
FileInfo csprojFile = new FileInfo(Path.Combine(_tempFolder.FullName, "ScriptProject.csproj"));
FileInfo globalFile = new FileInfo(Path.Combine(_tempFolder.FullName, "ScriptGlobals.cs"));
FileInfo scriptTemplate = new FileInfo(Path.Combine(_tempFolder.FullName, "ScriptTemplate.cs"));
var usings = scriptHandler.GetUsings();
var references = scriptHandler.GetReferences();
var globals = scriptHandler.GetGlobals();
File.WriteAllText(csprojFile.FullName, CreateProject(references));
File.WriteAllText(globalFile.FullName, CreateGlobals(usings, globals));
File.WriteAllText(scriptTemplate.FullName, CreateTemplate(usings));
// dotnet restore on the project just created
Process.Start(
new ProcessStartInfo
{
FileName = "dotnet",
Arguments = "restore",
WorkingDirectory = _tempFolder.FullName,
CreateNoWindow = true
});
// Start VS Code
Process.Start(
new ProcessStartInfo
{
FileName = "code",
Arguments = $"\"{_tempFolder.FullName}\" -g \"{scriptTemplate.FullName}\":{11 + usings.Length}:43",
CreateNoWindow = true
});
if (_watcher != null)
{
_watcher.Changed -= WatcherChanged;
_watcher.Dispose();
}
_watcher = new FileSystemWatcher(_tempFolder.FullName)
{
NotifyFilter = NotifyFilters.LastWrite,
Filter = "*ScriptTemplate.cs"
};
_watcher.Changed += WatcherChanged;
_watcher.EnableRaisingEvents = true;
}
/// <summary>
/// Set the actor's position
/// </summary>
/// <sqparam type="Vector3" name="position" optional=false>The Actor's position</sqparam>
/// <sqreturns></sqreturns>
private static int SetPosition(Squirrel vm, int argCount)
{
var self = (SqInstance)ScriptHandler.This;
var argPosition = ScriptHandler.GetArg <Vector3>(0);
var internalActor = self[RegisteredClass.HndInternalActor];
return(0);
}
private ActorClass() : base("Actor")
{
HndInternalActor = NewField("_InternalActor");
HndConstructor = SetConstructor(ScriptHandler.MakeFunction(Constructor));
HndSetPosition = NewMethod("SetPosition", ScriptHandler.MakeFunction(SetPosition));
HndSetPosition = NewMethod("SetHealth", ScriptHandler.MakeFunction(SetHealth));
}
public Account(AccountConfiguration accountConfiguration)
{
AccountConfiguration = accountConfiguration;
Logger = new Logger();
Game = new Game.Game(this);
CombatExtensions = new CombatExtensions(this);
ScriptHandler = new ScriptHandler(this);
}
void Awake()
{
MasterServer.ipAddress = "127.0.0.1";
MasterServer.port = 23466;
scriptHandler = GameObject.Find("ScriptHandler").GetComponent<ScriptHandler>();
uiHandler = GameObject.Find("UIHandler").GetComponent<UIHandler>();
InputName = (GameObject)Resources.Load("Prefabs/Input");
}
public SqInstance CallConstructor(params object[] arguments)
{
PushSelf();
PushSelf();
var inst = ScriptHandler.PopToCallAsMethod(-2, arguments)[0];
return(inst as SqInstance);
}
/// <summary>
/// Constructor
/// </summary>
/// <sqparam type="Vector3" name="position" optional=false>The Actor's position</sqparam>
/// <sqreturns></sqreturns>
private static int Constructor(Squirrel vm, int argCount)
{
var self = (SqInstance)ScriptHandler.This;
var argPosition = ScriptHandler.GetArg <Vector3>(0);
self.CallMember(RegisteredClass.HndSetPosition, argPosition);
self.CallMember(RegisteredClass.SetHealth, 100);
return(0);
}
public World()
{
this.url = "tcp://0.0.0.0";
this.running = true;
this.eventChannel = new Channel();
this.registered = new Dictionary <String, int>();
this.activeLock = new Mutex(false);
ScriptHandler.Register(new MoveScript());
}
public void ScriptExecutor_RunStaticScriptAndCommand_ResponseReturnTest()
{
scripts.Add(new Script {
Name = "Test1", Text = "function test() { return 20; }", IsStaticScript = true
});
ScriptHandler scriptHandler = new ScriptHandler();
Assert.AreEqual("20", scriptHandler.RunScript(eventInfo, "return test()"));
}
public void Disconnect()
{
Connection?.Dispose();
Connection = null;
ScriptHandler.StopScript();
Game.Clean();
AccountStatus = AccountStatus.Disconnected;
AccountDisconnectedEvent?.Invoke();
}
private static SqTable MakeMethods(Type type)
{
var methods = new SqTable();
// Get all methods by name
var dict = new Dictionary <string, List <MethodInfo> >();
foreach (var method in type.GetMethods(BindingFlags.Public | BindingFlags.Instance))
{
if (dict.TryGetValue(method.Name, out var already))
{
already.Add(method);
continue;
}
var list = new List <MethodInfo> {
method
};
dict.Add(method.Name, list);
}
// Convert methods
foreach (var kvp in dict)
{
var name = kvp.Key;
var overrides = kvp.Value;
methods[name] = ScriptHandler.MakeFunction(
(vm, argCount) =>
{
var self = (SqHostObject)ScriptHandler.This;
var possible = overrides
.Where(e => e.GetParameters().Length >= argCount);
if (!possible.Any())
{
throw new Exception($"No matching method {type}.{name} that can consume the given arguments");
}
var toCall = possible.OrderBy(e => e.GetParameters().Length).First();
var methodParams = toCall.GetParameters();
var args = new object[argCount];
for (var i = 0; i < argCount; i++)
{
args[i] = ScriptHandler.GetArg(i, methodParams[i].ParameterType, true);
}
try
{
vm.PushDynamic(toCall.Invoke(self.Object, args));
}
catch (TargetParameterCountException e)
{
throw new Exception($"Cannot call \"{name}\" with {argCount} arguments");
}
return(1);
}
);
}
return(methods);
}
public async Task InitScriptTest()
{
var scriptHandler = new ScriptHandler()
.AddReferences(typeof(string).Assembly)
.AddUsings("System")
.AddGlobals(("TestString", "TestStringValue"));
var initSucceeded = await scriptHandler.InitScript();
Assert.True(initSucceeded);
}
public void RegisterScriptHandler(string extension, ScriptHandler handler)
{
// Ensure the extension starts with a dot
if (!extension.StartsWith("."))
{
extension = "." + extension;
}
mCallbacks[extension] = handler;
}
public Script <T> TryGetScript <T>(ScriptHandler script) where T : Settings.ISettings
{
try
{
return((Script <T>)Delegate.CreateDelegate(typeof(Script <T>), script.Method));
}
catch
{
return(null);
}
}
/// <summary>
/// Loads a new script into the specified entity
/// </summary>
/// <param name="entity">Entity to be scripted</param>
/// <param name="script">The script to load</param>
public void AddScript(Entity entity, Script script)
{
try
{
ScriptHandler scriptHandler = new ScriptHandler(script, entity, this);
m_scriptHandlers.Add(scriptHandler.ScriptId, scriptHandler);
}
catch (Exception e)
{
OpenSim.Framework.Console.MainConsole.Instance.WriteLine("World.cs: AddScript() - Failed with exception " + e.ToString());
}
}
public void Selected(int selection)
{
GameData.CurrentSimpleEncounter.Attempted++;
var data = GameData.CurrentSimpleEncounter.Data;
// play sound
var index = data.ChoiceResultIndex[selection] - 1;
var CommandCodes = data.ChoiceCodes[index];
var ArgumentCodes = data.ChoiceArgs[index];
Debug.Log("Result #" + (index + 1) + " Codes: " + CommandCodes.ToPrettyString() + " args: " + ArgumentCodes.ToPrettyString());
adventureManager.textHandler.ClearText();
scriptHandler = new ScriptHandler(AdventureGameState.SimpleEncounter, CommandCodes, ArgumentCodes);
simpleEncounterGo.SetActive(false);
}
public static int Main(String[] args)
{
World world = new World();
world.Begin();
while (true)
{
Thread.Sleep(1000 / 60);
ScriptHandler.Step(1f / 60f);
}
world.End();
return(0);
}
//mxd
public ScriptHandler GetScriptHandler(ScriptType type)
{
Type t = typeof(ScriptHandler);
// Do we have a handler type for this?
if (scripthandlertypes.ContainsKey(type))
{
t = scripthandlertypes[type].Type;
}
// Create instance
ScriptHandler th = (ScriptHandler)General.ThisAssembly.CreateInstance(t.FullName);
return(th);
}
public void Context()
{
var typeFinder = MockRepository.GenerateMock<ITypeFinder>();
typeFinder.Stub(x => x.ListEventTypes()).Return(new[] {typeof (NoMembersEvent), typeof (MembersEvent)});
GlobalHost.DependencyResolver.Register(typeof(ITypeFinder), () => typeFinder);
var handler = new ScriptHandler<TestEventBase>();
var context = new HttpContext(
new HttpRequest("", "http://tempuri.org", ""),
new HttpResponse(new StringWriter())
);
handler.ProcessRequest(context);
script = context.Response.Output.ToString();
}
public async Task InitScriptCancellationTest()
{
var scriptHandler = new ScriptHandler()
.AddReferences(typeof(string).Assembly)
.AddUsings("System")
.AddGlobals(("TestString", "TestStringValue"));
var tokenSource = new CancellationTokenSource();
var token = tokenSource.Token;
tokenSource.Cancel();
var initSucceeded = await scriptHandler.InitScript(token);
Assert.False(initSucceeded);
}
/// <summary>
/// Called when starting the scene
/// </summary>
public override void OnStart()
{
Current = this;
TriangleRenderPass = new BasicRenderPass(Graphics);
ClearEffect = new ClearEffect(Graphics, TriangleRenderPass);
ClearEffect.Start();
ClearEffect.ClearColor = new ClearColorValue(0.5f, 0.7f, 0.9f);
TimerHandler = new TimerHandler(this);
PlayerHandler = new PlayerInterfaceHandler(1);
BulletHandler = new BulletHandler(this, 200000, ClearEffect);
BulletHandler.Start();
EnemyHandler = new EnemyHandler(this, 10000, BulletHandler.SpriteEffect);
EnemyHandler.Start();
ScriptHandler.ExecuteFile("demo.nut");
ScriptHandler.CallGlobal("main");
}
void Start()
{
handler = GameObject.Find("ScriptHandler").GetComponent<ScriptHandler>();
}
