Datasets:

ZHENGRAN

/

cross_code_eval_csharp

like 1

using LassoProcessManager.Models.Rules; using Newtonsoft.Json; using ProcessManager.Models.Configs; using System.Reflection; namespace ProcessManager.Providers { public class ConfigProvider : IConfigProvider { private const string ConfigFileName = "Config.json"; private ManagerConfig managerConfig; private ILogProvider LogProvider { get; set; } public ConfigProvider(ILogProvider logProvider) => this.LogProvider = logProvider; public ManagerConfig GetManagerConfig() { if (managerConfig != null) return managerConfig; string configPath = GetConfigFilePath(); try { managerConfig = JsonConvert.DeserializeObject<ManagerConfig>(File.ReadAllText(GetConfigFilePath())); return managerConfig; } catch { LogProvider.Log($"Failed to load config at '{configPath}'."); } return null; } public List<BaseRule> GetRules() { List<BaseRule> rules = new List<BaseRule>(); rules.AddRange(managerConfig.ProcessRules); rules.AddRange(managerConfig.FolderRules); return rules; } public Dictionary<string,

Dictionary<string, LassoProfile> lassoProfiles = new Dictionary<string, LassoProfile>(); // Load lasso profiles foreach (var profile in managerConfig.Profiles) { if (!lassoProfiles.ContainsKey(profile.Name)) { lassoProfiles.Add(profile.Name, profile); } } return lassoProfiles; } private string GetConfigFilePath() => Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), ConfigFileName); } }

LassoProfile> GetLassoProfiles() {

//#define PRINT_DEBUG using System; using System.IO; using Godot; using Mono.Unix; using Directory = System.IO.Directory; using Environment = System.Environment; using File = System.IO.File; using Path = System.IO.Path; namespace GodotLauncher { public class DataPaths { static string AppDataPath => Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData); static string BasePath => Path.Combine(AppDataPath, "ReadyToLaunch"); public static string platformOverride; public static string SanitizeProjectPath(string path) { if (File.Exists(path)) { path = new FileInfo(path).DirectoryName; } return path; } public static void EnsureProjectExists(string path) { var filePath = Path.Combine(path, "project.godot"); if (!File.Exists(filePath)) File.WriteAllText(filePath, ""); } public static string GetExecutablePath(InstallerEntryData installerEntryData) { string platformName = GetPlatformName(); string path = Path.Combine(BasePath, platformName, installerEntryData.BuildType, installerEntryData.version); path = Path.Combine(path, installerEntryData.ExecutableName); return path; } public static string GetPlatformName() { if (!string.IsNullOrEmpty(platformOverride)) return platformOverride; return OS.GetName(); } public static void WriteFile(string fileName, byte[] data) { var path = Path.Combine(BasePath, fileName); #if PRINT_DEBUG GD.Print("Writing: " + path); #endif File.WriteAllBytes(path, data); } public static void WriteFile(string fileName, string data) { var path = Path.Combine(BasePath, fileName); #if PRINT_DEBUG GD.Print("Writing: " + path); #endif File.WriteAllText(path, data); } public static string ReadFile(string fileName, string defaultData = null) { var path = Path.Combine(BasePath, fileName); if (File.Exists(path)) { #if PRINT_DEBUG GD.Print("Reading: " + path); #endif return File.ReadAllText(path); } #if PRINT_DEBUG GD.Print("File not found: " + path); #endif return defaultData; } public static bool ExecutableExists(

string path = GetExecutablePath(installerEntryData); bool exists = File.Exists(path); #if PRINT_DEBUG GD.Print("Checking if path exists: " + path + " exists=" + exists); #endif return exists; } public static void ExtractArchive(string fileName, InstallerEntryData installerEntryData) { string source = Path.Combine(BasePath, fileName); string dest = Path.Combine(BasePath, GetPlatformName(), installerEntryData.BuildType, installerEntryData.version); if (!Directory.Exists(dest)) System.IO.Compression.ZipFile.ExtractToDirectory(source, dest); File.Delete(source); } public static void DeleteVersion(string version, string buildType) { Directory.Delete(Path.Combine(BasePath, GetPlatformName(), buildType, version), true); } public static void LaunchGodot(InstallerEntryData installerEntryData, string arguments = "") { string path = GetExecutablePath(installerEntryData); #if PRINT_DEBUG GD.Print("Launching: " + path); #endif if (!OS.GetName().Equals("Windows")) { var unixFile = new UnixFileInfo(path); unixFile.FileAccessPermissions |= FileAccessPermissions.UserExecute | FileAccessPermissions.GroupExecute | FileAccessPermissions.OtherExecute; } using var process = new System.Diagnostics.Process(); process.StartInfo.FileName = path; process.StartInfo.WorkingDirectory = BasePath; process.StartInfo.Arguments = arguments; process.Start(); } public static void CreateInstallationDirectory() { MoveOldInstallationDirectory("ReadyForLaunch"); MoveOldInstallationDirectory("GodotLauncher"); Directory.CreateDirectory(BasePath); } static void MoveOldInstallationDirectory(string oldName) { var oldPath = Path.Combine(AppDataPath, oldName); if (!Directory.Exists(oldPath) || Directory.Exists(BasePath)) return; Directory.Move(oldPath, BasePath); } public static void ShowInFolder(string filePath) { filePath = "\"" + filePath + "\""; switch (OS.GetName()) { case "Linux": System.Diagnostics.Process.Start("xdg-open", filePath); break; case "Windows": string argument = "/select, " + filePath; System.Diagnostics.Process.Start("explorer.exe", argument); break; case "macOS": System.Diagnostics.Process.Start("open", filePath); break; default: throw new Exception("OS not defined! " + OS.GetName()); } } } }

InstallerEntryData installerEntryData) {

using Newtonsoft.Json; namespace DotNetDevBadgeWeb.Model { public class UserSummary { [

get; set; } [JsonProperty("likes_received")] public int LikesReceived { get; set; } [JsonProperty("topics_entered")] public int TopicsEntered { get; set; } [JsonProperty("posts_read_count")] public int PostsReadCount { get; set; } [JsonProperty("days_visited")] public int DaysVisited { get; set; } [JsonProperty("topic_count")] public int TopicCount { get; set; } [JsonProperty("post_count")] public int PostCount { get; set; } [JsonProperty("time_read")] public int TimeRead { get; set; } [JsonProperty("recent_time_read")] public int RecentTimeRead { get; set; } [JsonProperty("bookmark_count")] public int BookmarkCount { get; set; } [JsonProperty("can_see_summary_stats")] public bool CanSeeSummaryStats { get; set; } [JsonProperty("solved_count")] public int SolvedCount { get; set; } } }

JsonProperty("likes_given")] public int LikesGiven {

using System.Collections.Generic; namespace JdeJabali.JXLDataTableExtractor.JXLExtractedData { public class JXLDataExtracted { public List<

get; set; } = new List<JXLWorkbookData>(); } }

JXLWorkbookData> WorkbooksData {

using System.Net.WebSockets; using System.Text; using Microsoft.AspNetCore.Http; using Newtonsoft.Json; namespace TraTech.WebSocketHub { public class WebSocketHubMiddleware<TKey> where TKey : notnull { private readonly IServiceProvider _serviceProvider; private readonly RequestDelegate _next; private readonly Func<HttpContext, bool> _acceptIf; private readonly WebSocketHub<TKey> _webSocketHub; private readonly Func<HttpContext, TKey> _keyGenerator; private readonly byte[] _receiveBuffer; public WebSocketHubMiddleware(IServiceProvider serviceProvider, RequestDelegate next,

_serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider)); _next = next ?? throw new ArgumentNullException(nameof(next)); _acceptIf = acceptIf ?? throw new ArgumentNullException(nameof(acceptIf)); _webSocketHub = webSocketHub ?? throw new ArgumentNullException(nameof(webSocketHub)); _keyGenerator = keyGenerator ?? throw new ArgumentNullException(nameof(keyGenerator)); _receiveBuffer = new byte[_webSocketHub.Options.ReceiveBufferSize]; } public async Task Invoke(HttpContext httpContext) { if (httpContext.WebSockets.IsWebSocketRequest && _acceptIf(httpContext)) { try { WebSocket webSocket = await httpContext.WebSockets.AcceptWebSocketAsync(); var key = _keyGenerator(httpContext); _webSocketHub.Add(key, webSocket); while (webSocket.State == WebSocketState.Open || webSocket.State == WebSocketState.CloseSent) { try { WebSocketReceiveResult result = await webSocket.ReceiveAsync(new ArraySegment<byte>(_receiveBuffer), CancellationToken.None); string request = Encoding.UTF8.GetString(_receiveBuffer, 0, result.Count); if (result.MessageType == WebSocketMessageType.Close) { break; } Message? serializedRequest = _webSocketHub.DeserializeMessage(request); if (serializedRequest == null) { throw new NullReferenceException(nameof(serializedRequest)); } Type? handlerType = await _webSocketHub.Options.WebSocketRequestHandler.GetHandlerAsync(serializedRequest.Type); if (handlerType == null) { throw new NullReferenceException(nameof(handlerType)); } if (_serviceProvider.GetService(handlerType) is not IWebSocketRequestHandler service) { throw new NullReferenceException(nameof(service)); } await service.HandleRequestAsync( JsonConvert.SerializeObject(key, _webSocketHub.Options.JsonSerializerSettings), JsonConvert.SerializeObject(serializedRequest.Payload, _webSocketHub.Options.JsonSerializerSettings) ); } catch (Exception exp) { Console.WriteLine(exp.ToString()); continue; } } await _webSocketHub.RemoveAsync(key, webSocket); } catch (Exception exp) { Console.WriteLine(exp.ToString()); } } else { await _next(httpContext); } } } }

WebSocketHub<TKey> webSocketHub, Func<HttpContext, bool> acceptIf, Func<HttpContext, TKey> keyGenerator) {

using System.Text; using System.Net; using Microsoft.Extensions.Caching.Memory; using Serilog; using Serilog.Events; using Iced.Intel; using static Iced.Intel.AssemblerRegisters; namespace OGXbdmDumper { public class Xbox : IDisposable { #region Properties private bool _disposed; private const int _cacheDuration = 1; // in minutes private readonly MemoryCache _cache = new MemoryCache(new MemoryCacheOptions { ExpirationScanFrequency = TimeSpan.FromMinutes(_cacheDuration) }); private bool? _hasFastGetmem; public ScratchBuffer StaticScratch; public bool HasFastGetmem { get { if (_hasFastGetmem == null) { try { long testAddress = 0x10000; if (IsValidAddress(testAddress)) { Session.SendCommandStrict("getmem2 addr={0} length=1", testAddress.ToHexString()); Session.ClearReceiveBuffer(); _hasFastGetmem = true; Log.Information("Fast getmem support detected."); } else _hasFastGetmem = false; } catch { _hasFastGetmem = false; } } return _hasFastGetmem.Value; } } /// <summary> /// Determines whether precautions (usually at the expense of performance) should be taken to prevent crashing the xbox. /// </summary> public bool SafeMode { get; set; } = true; public bool IsConnected => Session.IsConnected; public int SendTimeout { get => Session.SendTimeout; set => Session.SendTimeout = value; } public int ReceiveTimeout { get => Session.ReceiveTimeout; set => Session.ReceiveTimeout = value; } public Connection Session { get; private set; } = new Connection(); public ConnectionInfo? ConnectionInfo { get; protected set; } /// <summary> /// The Xbox memory stream. /// </summary> public XboxMemoryStream Memory { get; private set; } public Kernel Kernel { get; private set; } public List<Module> Modules => GetModules(); public List<

public Version Version => GetVersion(); #endregion #region Connection public void Connect(string host, int port = 731) { _cache.Clear(); ConnectionInfo = Session.Connect(host, port); // init subsystems Memory = new XboxMemoryStream(this); Kernel = new Kernel(this); StaticScratch = new ScratchBuffer(this); Log.Information("Loaded Modules:"); foreach (var module in Modules) { Log.Information("\t{0} ({1})", module.Name, module.TimeStamp); } Log.Information("Xbdm Version {0}", Version); Log.Information("Kernel Version {0}", Kernel.Version); // enable remote code execution and use the remainder reloc section as scratch PatchXbdm(this); } public void Disconnect() { Session.Disconnect(); ConnectionInfo = null; _cache.Clear(); } public List<ConnectionInfo> Discover(int timeout = 500) { return ConnectionInfo.DiscoverXbdm(731, timeout); } public void Connect(IPEndPoint endpoint) { Connect(endpoint.Address.ToString(), endpoint.Port); } public void Connect(int timeout = 500) { Connect(Discover(timeout).First().Endpoint); } #endregion #region Memory public bool IsValidAddress(long address) { try { Session.SendCommandStrict("getmem addr={0} length=1", address.ToHexString()); return "??" != Session.ReceiveMultilineResponse()[0]; } catch { return false; } } public void ReadMemory(long address, Span<byte> buffer) { if (HasFastGetmem && !SafeMode) { Session.SendCommandStrict("getmem2 addr={0} length={1}", address.ToHexString(), buffer.Length); Session.Read(buffer); if (Log.IsEnabled(LogEventLevel.Verbose)) { Log.Verbose(buffer.ToHexString()); } } else if (!SafeMode) { // custom getmem2 Session.SendCommandStrict("funccall type=1 addr={0} length={1}", address, buffer.Length); Session.ReadExactly(buffer); if (Log.IsEnabled(LogEventLevel.Verbose)) { Log.Verbose(buffer.ToHexString()); } } else { Session.SendCommandStrict("getmem addr={0} length={1}", address.ToHexString(), buffer.Length); int bytesRead = 0; string hexString; while ((hexString = Session.ReceiveLine()) != ".") { Span<byte> slice = buffer.Slice(bytesRead, hexString.Length / 2); slice.FromHexString(hexString); bytesRead += slice.Length; } } } public void ReadMemory(long address, byte[] buffer, int offset, int count) { ReadMemory(address, buffer.AsSpan(offset, count)); } public void ReadMemory(long address, int count, Stream destination) { // argument checks if (address < 0) throw new ArgumentOutOfRangeException(nameof(address)); if (count <= 0) throw new ArgumentOutOfRangeException(nameof(count)); if (destination == null) throw new ArgumentNullException(nameof(destination)); Span<byte> buffer = stackalloc byte[1024 * 80]; while (count > 0) { int bytesToRead = Math.Min(buffer.Length, count); Span<byte> slice = buffer.Slice(0, bytesToRead); ReadMemory(address, slice); destination.Write(slice); count -= bytesToRead; address += (uint)bytesToRead; } } public void WriteMemory(long address, ReadOnlySpan<byte> buffer) { const int maxBytesPerLine = 240; int totalWritten = 0; while (totalWritten < buffer.Length) { ReadOnlySpan<byte> slice = buffer.Slice(totalWritten, Math.Min(maxBytesPerLine, buffer.Length - totalWritten)); Session.SendCommandStrict("setmem addr={0} data={1}", (address + totalWritten).ToHexString(), slice.ToHexString()); totalWritten += slice.Length; } } public void WriteMemory(long address, byte[] buffer, int offset, int count) { WriteMemory(address, buffer.AsSpan(offset, count)); } public void WriteMemory(long address, int count, Stream source) { // argument checks if (address < 0) throw new ArgumentOutOfRangeException(nameof(address)); if (count <= 0) throw new ArgumentOutOfRangeException(nameof(count)); if (source == null) throw new ArgumentNullException(nameof(source)); Span<byte> buffer = stackalloc byte[1024 * 80]; while (count > 0) { int bytesRead = source.Read(buffer.Slice(0, Math.Min(buffer.Length, count))); WriteMemory(address, buffer.Slice(0, bytesRead)); count -= bytesRead; address += bytesRead; } } #endregion #region Process public List<Thread> GetThreads() { List<Thread> threads = new List<Thread>(); Session.SendCommandStrict("threads"); foreach (var threadId in Session.ReceiveMultilineResponse()) { Session.SendCommandStrict("threadinfo thread={0}", threadId); var info = Connection.ParseKvpResponse(string.Join(Environment.NewLine, Session.ReceiveMultilineResponse())); threads.Add(new Thread { Id = Convert.ToInt32(threadId), Suspend = (int)(uint)info["suspend"], // initially -1 in earlier xbdm versions, 0 in later ones Priority = (int)(uint)info["priority"], TlsBase = (uint)info["tlsbase"], // optional depending on xbdm version Start = info.ContainsKey("start") ? (uint)info["start"] : 0, Base = info.ContainsKey("base") ? (uint)info["base"] : 0, Limit = info.ContainsKey("limit") ? (uint)info["limit"] : 0, CreationTime = DateTime.FromFileTime( (info.ContainsKey("createhi") ? (((long)(uint)info["createhi"]) << 32) : 0) | (info.ContainsKey("createlo") ? (uint)info["createlo"] : 0)) }); } return threads; } public List<Module> GetModules() { List<Module> modules = new List<Module>(); Session.SendCommandStrict("modules"); foreach (var moduleResponse in Session.ReceiveMultilineResponse()) { var moduleInfo = Connection.ParseKvpResponse(moduleResponse); Module module = new Module { Name = (string)moduleInfo["name"], BaseAddress = (uint)moduleInfo["base"], Size = (int)(uint)moduleInfo["size"], Checksum = (uint)moduleInfo["check"], TimeStamp = DateTimeOffset.FromUnixTimeSeconds((uint)moduleInfo["timestamp"]).DateTime, Sections = new List<ModuleSection>(), HasTls = moduleInfo.ContainsKey("tls"), IsXbe = moduleInfo.ContainsKey("xbe") }; Session.SendCommandStrict("modsections name=\"{0}\"", module.Name); foreach (var sectionResponse in Session.ReceiveMultilineResponse()) { var sectionInfo = Connection.ParseKvpResponse(sectionResponse); module.Sections.Add(new ModuleSection { Name = (string)sectionInfo["name"], Base = (uint)sectionInfo["base"], Size = (int)(uint)sectionInfo["size"], Flags = (uint)sectionInfo["flags"] }); } modules.Add(module); } return modules; } public Version GetVersion() { var version = _cache.Get<Version>(nameof(GetVersion)); if (version == null) { try { // peek inside VS_VERSIONINFO struct var versionAddress = GetModules().FirstOrDefault(m => m.Name.Equals("xbdm.dll")).GetSection(".rsrc").Base + 0x98; // call getmem directly to avoid dependency loops with ReadMemory checking the version Span<byte> buffer = stackalloc byte[sizeof(ushort) * 4]; Session.SendCommandStrict("getmem addr={0} length={1}", versionAddress.ToHexString(), buffer.Length); buffer.FromHexString(Session.ReceiveMultilineResponse().First()); version = new Version( BitConverter.ToUInt16(buffer.Slice(2, sizeof(ushort))), BitConverter.ToUInt16(buffer.Slice(0, sizeof(ushort))), BitConverter.ToUInt16(buffer.Slice(6, sizeof(ushort))), BitConverter.ToUInt16(buffer.Slice(4, sizeof(ushort))) ); // cache the result _cache.Set(nameof(GetVersion), version); } catch { version = new Version("0.0.0.0"); } } return version; } public void Stop() { Log.Information("Suspending xbox execution."); Session.SendCommand("stop"); } public void Go() { Log.Information("Resuming xbox execution."); Session.SendCommand("go"); } /// <summary> /// Calls an Xbox function. /// </summary> /// <param name="address">The function address.</param> /// <param name="args">The function arguments.</param> /// <returns>Returns an object that unboxes eax by default, but allows for reading st0 for floating-point return values.</returns> public uint Call(long address, params object[] args) { // TODO: call context (~4039+ which requires qwordparam) // injected script pushes arguments in reverse order for simplicity, this corrects that var reversedArgs = args.Reverse().ToArray(); StringBuilder command = new StringBuilder(); command.AppendFormat("funccall type=0 addr={0} ", address); for (int i = 0; i < reversedArgs.Length; i++) { command.AppendFormat("arg{0}={1} ", i, Convert.ToUInt32(reversedArgs[i])); } var returnValues = Connection.ParseKvpResponse(Session.SendCommandStrict(command.ToString()).Message); return (uint)returnValues["eax"]; } /// <summary> /// Original Xbox Debug Monitor runtime patches. /// Prevents crashdumps from being written to the HDD and enables remote code execution. /// </summary> /// <param name="target"></param> private void PatchXbdm(Xbox target) { // the spin routine to be patched in after the signature patterns // spin: // jmp spin // int 3 var spinBytes = new byte[] { 0xEB, 0xFE, 0xCC }; // prevent crashdumps from being written to the hard drive by making it spin instead (only for xbdm versions ~4831+) if (target.Signatures.ContainsKey("ReadWriteOneSector")) { Log.Information("Disabling crashdump functionality."); target.WriteMemory(target.Signatures["ReadWriteOneSector"] + 9, spinBytes); } else if (target.Signatures.ContainsKey("WriteSMBusByte")) { // this will prevent the LED state from changing upon crash Log.Information("Disabling crashdump functionality."); target.WriteMemory(target.Signatures["WriteSMBusByte"] + 9, spinBytes); } Log.Information("Patching xbdm memory to enable remote code execution."); uint argThreadStringAddress = StaticScratch.Alloc("thread\0"); uint argTypeStringAddress = StaticScratch.Alloc("type\0"); uint argAddrStringAddress = StaticScratch.Alloc("addr\0"); uint argLengthStringAddress = StaticScratch.Alloc("length\0"); uint argFormatStringAddress = StaticScratch.Alloc("arg%01d\0"); uint returnFormatAddress = StaticScratch.Alloc("eax=0x%X\0"); var asm = new Assembler(32); #region HrSendGetMemory2Data uint getmem2CallbackAddress = 0; if (!HasFastGetmem) { // labels var label1 = asm.CreateLabel(); var label2 = asm.CreateLabel(); var label3 = asm.CreateLabel(); asm.push(ebx); asm.mov(ebx, __dword_ptr[esp + 8]); // pdmcc asm.mov(eax, __dword_ptr[ebx + 0x14]); // size asm.test(eax, eax); asm.mov(edx, __dword_ptr[ebx + 0x10]); asm.ja(label1); //asm.push(__dword_ptr[ebx + 8]); //asm.call((uint)target.Signatures["DmFreePool"]); //asm.and(__dword_ptr[ebx + 8], 0); asm.mov(eax, 0x82DB0104); asm.jmp(label3); asm.Label(ref label1); asm.mov(ecx, __dword_ptr[ebx + 0xC]); // buffer size asm.cmp(eax, ecx); asm.jb(label2); asm.mov(eax, ecx); asm.Label(ref label2); asm.push(ebp); asm.push(esi); asm.mov(esi, __dword_ptr[edx + 0x14]); // address asm.push(edi); asm.mov(edi, __dword_ptr[ebx + 8]); asm.mov(ecx, eax); asm.mov(ebp, ecx); asm.shr(ecx, 2); asm.rep.movsd(); asm.mov(ecx, ebp); asm.and(ecx, 3); asm.rep.movsb(); asm.sub(__dword_ptr[ebx + 0x14], eax); asm.pop(edi); asm.mov(__dword_ptr[ebx + 4], eax); asm.add(__dword_ptr[edx + 0x14], eax); asm.pop(esi); asm.mov(eax, 0x2DB0000); asm.pop(ebp); asm.Label(ref label3); asm.pop(ebx); asm.ret(0xC); getmem2CallbackAddress = StaticScratch.Alloc(asm.AssembleBytes(StaticScratch.Region.Address)); } #endregion #region HrFunctionCall // 3424+ as it depends on sprintf within xbdm, earlier versions can possibly call against the kernel but their exports are different asm = new Assembler(32); // labels var binaryResponseLabel = asm.CreateLabel(); var getmem2Label = asm.CreateLabel(); var errorLabel = asm.CreateLabel(); var successLabel = asm.CreateLabel(); // prolog asm.push(ebp); asm.mov(ebp, esp); asm.sub(esp, 0x10); // carve out arbitrary space for local temp variables asm.pushad(); // disable write protection globally, otherwise checked kernel calls may fail when writing to the default scratch space asm.mov(eax, cr0); asm.and(eax, 0xFFFEFFFF); asm.mov(cr0, eax); // arguments var commandPtr = ebp + 0x8; var responseAddress = ebp + 0xC; var pdmcc = ebp + 0x14; // local variables var temp = ebp - 0x4; var callAddress = ebp - 0x8; var argName = ebp - 0x10; // check for thread id asm.lea(eax, temp); asm.push(eax); asm.push(argThreadStringAddress); // 'thread', 0 asm.push(__dword_ptr[commandPtr]); asm.call((uint)target.Signatures["FGetDwParam"]); asm.test(eax, eax); var customCommandLabel = asm.CreateLabel(); asm.je(customCommandLabel); // call original code if thread id exists asm.push(__dword_ptr[temp]); asm.call((uint)target.Signatures["DmSetupFunctionCall"]); var doneLabel = asm.CreateLabel(); asm.jmp(doneLabel); // thread argument doesn't exist, must be a custom command asm.Label(ref customCommandLabel); // determine custom function type asm.lea(eax, temp); asm.push(eax); asm.push(argTypeStringAddress); // 'type', 0 asm.push(__dword_ptr[commandPtr]); asm.call((uint)target.Signatures["FGetDwParam"]); asm.test(eax, eax); asm.je(errorLabel); #region Custom Call (type 0) asm.cmp(__dword_ptr[temp], 0); asm.jne(getmem2Label); // get the call address asm.lea(eax, __dword_ptr[callAddress]); asm.push(eax); asm.push(argAddrStringAddress); // 'addr', 0 asm.push(__dword_ptr[commandPtr]); asm.call((uint)target.Signatures["FGetDwParam"]); asm.test(eax, eax); asm.je(errorLabel); // push arguments (leave it up to caller to reverse argument order and supply the correct amount) asm.xor(edi, edi); var nextArgLabel = asm.CreateLabel(); var noMoreArgsLabel = asm.CreateLabel(); asm.Label(ref nextArgLabel); { // get argument name asm.push(edi); // argument index asm.push(argFormatStringAddress); // format string address asm.lea(eax, __dword_ptr[argName]); // argument name address asm.push(eax); asm.call((uint)target.Signatures["sprintf"]); asm.add(esp, 0xC); // check if it's included in the command asm.lea(eax, __[temp]); // argument value address asm.push(eax); asm.lea(eax, __[argName]); // argument name address asm.push(eax); asm.push(__dword_ptr[commandPtr]); // command asm.call((uint)target.Signatures["FGetDwParam"]); asm.test(eax, eax); asm.je(noMoreArgsLabel); // push it on the stack asm.push(__dword_ptr[temp]); asm.inc(edi); // move on to the next argument asm.jmp(nextArgLabel); } asm.Label(ref noMoreArgsLabel); // perform the call asm.call(__dword_ptr[callAddress]); // print response message asm.push(eax); // integer return value asm.push(returnFormatAddress); // format string address asm.push(__dword_ptr[responseAddress]); // response address asm.call((uint)target.Signatures["sprintf"]); asm.add(esp, 0xC); asm.jmp(successLabel); #endregion #region Fast Getmem (type 1) asm.Label(ref getmem2Label); asm.cmp(__dword_ptr[temp], 1); asm.jne(errorLabel); if (!HasFastGetmem) { // TODO: figure out why DmAllocatePool crashes, for now, allocate static scratch space (prevents multi-session!) StaticScratch.Align16(); uint getmem2BufferSize = 512; uint getmem2buffer = StaticScratch.Alloc(new byte[getmem2BufferSize]); // get length and size args asm.mov(esi, __dword_ptr[pdmcc]); asm.push(__dword_ptr[responseAddress]); asm.mov(edi, __dword_ptr[esi + 0x10]); asm.lea(eax, __dword_ptr[pdmcc]); asm.push(eax); asm.push(argAddrStringAddress); asm.push(__dword_ptr[commandPtr]); asm.call((uint)target.Signatures["FGetNamedDwParam"]); asm.test(eax, eax); asm.jz(errorLabel); asm.push(__dword_ptr[responseAddress]); asm.lea(eax, __dword_ptr[responseAddress]); asm.push(eax); asm.push(argLengthStringAddress); asm.push(__dword_ptr[commandPtr]); asm.call((uint)target.Signatures["FGetNamedDwParam"]); asm.test(eax, eax); asm.jz(errorLabel); asm.mov(eax, __dword_ptr[pdmcc]); // address asm.and(__dword_ptr[edi + 0x10], 0); asm.mov(__dword_ptr[edi + 0x14], eax); //asm.mov(eax, 0x2000); // TODO: increase pool size? //asm.push(eax); //asm.call((uint)target.Signatures["DmAllocatePool"]); // TODO: crashes in here, possible IRQ issues? asm.mov(__dword_ptr[esi + 0xC], getmem2BufferSize); // buffer size asm.mov(__dword_ptr[esi + 8], getmem2buffer); // buffer address asm.mov(eax, __dword_ptr[responseAddress]); asm.mov(__dword_ptr[esi + 0x14], eax); asm.mov(__dword_ptr[esi], getmem2CallbackAddress); asm.jmp(binaryResponseLabel); } #endregion #region Return Codes // if we're here, must be an unknown custom type asm.jmp(errorLabel); // generic success epilog asm.Label(ref successLabel); asm.popad(); asm.leave(); asm.mov(eax, 0x2DB0000); asm.ret(0x10); // successful binary response follows epilog asm.Label(ref binaryResponseLabel); asm.popad(); asm.leave(); asm.mov(eax, 0x2DB0003); asm.ret(0x10); // generic failure epilog asm.Label(ref errorLabel); asm.popad(); asm.leave(); asm.mov(eax, 0x82DB0000); asm.ret(0x10); // original epilog asm.Label(ref doneLabel); asm.popad(); asm.leave(); asm.ret(0x10); #endregion // inject RPC handler and hook uint caveAddress = StaticScratch.Alloc(asm.AssembleBytes(StaticScratch.Region.Address)); Log.Information("HrFuncCall address {0}", caveAddress.ToHexString()); asm.Hook(target, target.Signatures["HrFunctionCall"], caveAddress); #endregion } public string GetDisassembly(long address, int length, bool tabPrefix = true, bool showBytes = false) { // read code from xbox memory byte[] code = Memory.ReadBytes(address, length); // disassemble valid instructions var decoder = Iced.Intel.Decoder.Create(32, code); decoder.IP = (ulong)address; var instructions = new List<Instruction>(); while (decoder.IP < decoder.IP + (uint)code.Length) { var insn = decoder.Decode(); if (insn.IsInvalid) break; instructions.Add(insn); } // formatting options var formatter = new MasmFormatter(); formatter.Options.FirstOperandCharIndex = 8; formatter.Options.SpaceAfterOperandSeparator = true; // convert to string var output = new StringOutput(); var disassembly = new StringBuilder(); bool firstInstruction = true; foreach (var instr in instructions) { // skip newline for the first instruction if (firstInstruction) { firstInstruction = false; } else disassembly.AppendLine(); // optionally indent if (tabPrefix) { disassembly.Append('\t'); } // output address disassembly.Append(instr.IP.ToString("X8")); disassembly.Append(' '); // optionally output instruction bytes if (showBytes) { for (int i = 0; i < instr.Length; i++) disassembly.Append(code[(int)(instr.IP - (ulong)address) + i].ToString("X2")); int missingBytes = 10 - instr.Length; for (int i = 0; i < missingBytes; i++) disassembly.Append(" "); disassembly.Append(' '); } // output the decoded instruction formatter.Format(instr, output); disassembly.Append(output.ToStringAndReset()); } return disassembly.ToString(); } public Dictionary<string, long> Signatures { get { var signatures = _cache.Get<Dictionary<string, long>>(nameof(Signatures)); if (signatures == null) { var resolver = new SignatureResolver { // NOTE: ensure patterns don't overlap with any hooks! that way we don't have to cache any states; simplicity at the expense of slightly less perf on connect // universal pattern new SodmaSignature("ReadWriteOneSector") { // mov ebp, esp new OdmPattern(0x1, new byte[] { 0x8B, 0xEC }), // mov dx, 1F6h new OdmPattern(0x3, new byte[] { 0x66, 0xBA, 0xF6, 0x01 }), // mov al, 0A0h new OdmPattern(0x7, new byte[] { 0xB0, 0xA0 }) }, // universal pattern new SodmaSignature("WriteSMBusByte") { // mov al, 20h new OdmPattern(0x3, new byte[] { 0xB0, 0x20 }), // mov dx, 0C004h new OdmPattern(0x5, new byte[] { 0x66, 0xBA, 0x04, 0xC0 }), }, // universal pattern new SodmaSignature("FGetDwParam") { // jz short 0x2C new OdmPattern(0x15, new byte[] { 0x74, 0x2C }), // push 20h new OdmPattern(0x17, new byte[] { 0x6A, 0x20 }), // mov [ecx], eax new OdmPattern(0x33, new byte[] { 0x89, 0x01 }) }, // universal pattern new SodmaSignature("FGetNamedDwParam") { // mov ebp, esp new OdmPattern(0x1, new byte[] { 0x8B, 0xEC }), // jnz short 0x17 new OdmPattern(0x13, new byte[] { 0x75, 0x17 }), // retn 10h new OdmPattern(0x30, new byte[] { 0xC2, 0x10, 0x00 }) }, // universal pattern new SodmaSignature("DmSetupFunctionCall") { // test ax, 280h new OdmPattern(0x45, new byte[] { 0x66, 0xA9, 0x80, 0x02 }), // push 63666D64h new OdmPattern(0x54, new byte[] { 0x68, 0x64, 0x6D, 0x66, 0x63 }) }, // early revisions new SodmaSignature("HrFunctionCall") { // mov eax, 80004005h new OdmPattern(0x1B, new byte[] { 0xB8, 0x05, 0x40, 0x00, 0x80 }), // mov ebx, 10008h new OdmPattern(0x46, new byte[] { 0xBB, 0x08, 0x00, 0x01, 0x00 }) }, // later revisions new SodmaSignature("HrFunctionCall") { // mov eax, 80004005h new OdmPattern(0x1B, new byte[] { 0xB8, 0x05, 0x40, 0x00, 0x80 }), // mov ebx, 10008h new OdmPattern(0x45, new byte[] { 0xBB, 0x08, 0x00, 0x01, 0x00 }) }, // xbdm 3424+ contains this (3223 does not, who knows what inbetween does) whereas some early kernel versions do not? or have different kernel export tables for alpha/dvt3/dvt4/dvt6 etc. new SodmaSignature("sprintf") { // mov esi, [ebp+arg_0] new OdmPattern(0x7, new byte[] { 0x8B, 0x75, 0x08 }), // mov [ebp+var_1C], 7FFFFFFFh new OdmPattern(0x16, new byte[] { 0xC7, 0x45, 0xE4, 0xFF, 0xFF, 0xFF, 0x7F }) }, // early revisions new SodmaSignature("DmAllocatePool") { // push ebp new OdmPattern(0x0, new byte[] { 0x55 }), // mov ebp, esp new OdmPattern(0x0, new byte[] { 0x8B, 0xEC }), // push 'enoN' new OdmPattern(0x3, new byte[] { 0x68, 0x4E, 0x6F, 0x6E, 0x65 }) }, // later revisions new SodmaSignature("DmAllocatePool") { // push 'enoN' new OdmPattern(0x0, new byte[] { 0x68, 0x4E, 0x6F, 0x6E, 0x65 }), // retn 4 new OdmPattern(0xE, new byte[] { 0xC2, 0x04, 0x00 }) }, // universal pattern new SodmaSignature("DmFreePool") { // cmp eax, 0B0000000h new OdmPattern(0xF, new byte[] { 0x3D, 0x00, 0x00, 0x00, 0xB0 }) } }; // read xbdm .text section var xbdmTextSegment = GetModules().FirstOrDefault(m => m.Name.Equals("xbdm.dll")).GetSection(".text"); byte[] data = new byte[xbdmTextSegment.Size]; ReadMemory(xbdmTextSegment.Base, data); // scan for signatures signatures = resolver.Resolve(data, xbdmTextSegment.Base); // cache the result indefinitely _cache.Set(nameof(Signatures), signatures); } return signatures; } } #endregion #region File public char[] GetDrives() { return Session.SendCommandStrict("drivelist").Message.ToCharArray(); } public List<XboxFileInformation> GetDirectoryList(string path) { var list = new List<XboxFileInformation>(); Session.SendCommandStrict("dirlist name=\"{0}\"", path); foreach (string file in Session.ReceiveMultilineResponse()) { var fileInfo = file.ParseXboxResponseLine(); var info = new XboxFileInformation(); info.FullName = Path.Combine(path, (string)fileInfo["name"]); info.Size = ((long)fileInfo["sizehi"] << 32) | (long)fileInfo["sizelo"]; info.CreationTime = DateTime.FromFileTimeUtc(((long)fileInfo["createhi"] << 32) | (long)fileInfo["createlo"]); info.ChangeTime = DateTime.FromFileTimeUtc(((long)fileInfo["changehi"] << 32) | (long)fileInfo["changelo"]); info.Attributes |= file.Contains("directory") ? FileAttributes.Directory : FileAttributes.Normal; info.Attributes |= file.Contains("readonly") ? FileAttributes.ReadOnly : 0; info.Attributes |= file.Contains("hidden") ? FileAttributes.Hidden : 0; list.Add(info); } return list; } public void GetFile(string localPath, string remotePath) { Session.SendCommandStrict("getfile name=\"{0}\"", remotePath); using var lfs = File.Create(localPath); Session.CopyToCount(lfs, Session.Reader.ReadInt32()); } #endregion #region IDisposable protected virtual void Dispose(bool disposing) { if (!_disposed) { if (disposing) { // TODO: dispose managed state (managed objects) } // TODO: free unmanaged resources (unmanaged objects) and override finalizer Session?.Dispose(); // TODO: set large fields to null _disposed = true; } } ~Xbox() { Dispose(false); } public void Dispose() { Dispose(true); GC.SuppressFinalize(this); } #endregion } }

Thread> Threads => GetThreads();

using JWLSLMerge.Data.Attributes; namespace JWLSLMerge.Data.Models { public class Note { [

get; set; } public string Guid { get; set; } = null!; public int? UserMarkId { get; set; } public int? LocationId { get; set; } public string? Title { get; set; } public string? Content { get; set; } public string LastModified { get; set; } = null!; public string Created { get; set; } = null!; public int BlockType { get; set; } public int? BlockIdentifier { get; set; } [Ignore] public int NewNoteId { get; set; } } }

Ignore] public int NoteId {

using System; using System.ComponentModel; using System.Diagnostics; using System.IO; using System.Linq; using System.Runtime.InteropServices; using System.Runtime.Versioning; using System.Threading; using static ServiceSelf.AdvApi32; namespace ServiceSelf { sealed class WindowsService : Service { private const string WorkingDirArgName = "WD"; [SupportedOSPlatform("windows")] public WindowsService(string name) : base(name) { } /// <summary> /// 应用工作目录 /// </summary> /// <param name="args">启动参数</param> /// <returns></returns> public static bool UseWorkingDirectory(string[] args) { if (Argument.TryGetValue(args, WorkingDirArgName, out var workingDir)) { Environment.CurrentDirectory = workingDir; return true; } return false; } [SupportedOSPlatform("windows")] public override void CreateStart(string filePath, ServiceOptions options) { using var managerHandle = OpenSCManager(null, null, ServiceManagerAccess.SC_MANAGER_ALL_ACCESS); if (managerHandle.IsInvalid == true) { throw new Win32Exception(); } filePath = Path.GetFullPath(filePath); using var oldServiceHandle = OpenService(managerHandle, this.Name, ServiceAccess.SERVICE_ALL_ACCESS); if (oldServiceHandle.IsInvalid) { using var newServiceHandle = this.CreateService(managerHandle, filePath, options); StartService(newServiceHandle); } else { var oldFilePath = QueryServiceFilePath(oldServiceHandle); if (oldFilePath.Length > 0 && oldFilePath.Equals(filePath, StringComparison.OrdinalIgnoreCase) == false) { throw new InvalidOperationException("系统已存在同名但不同路径的服务"); } StartService(oldServiceHandle); } } private unsafe

var arguments = options.Arguments ?? Enumerable.Empty<Argument>(); arguments = string.IsNullOrEmpty(options.WorkingDirectory) ? arguments.Append(new Argument(WorkingDirArgName, Path.GetDirectoryName(filePath))) : arguments.Append(new Argument(WorkingDirArgName, Path.GetFullPath(options.WorkingDirectory))); var serviceHandle = AdvApi32.CreateService( managerHandle, this.Name, options.Windows.DisplayName, ServiceAccess.SERVICE_ALL_ACCESS, ServiceType.SERVICE_WIN32_OWN_PROCESS, ServiceStartType.SERVICE_AUTO_START, ServiceErrorControl.SERVICE_ERROR_NORMAL, $@"""{filePath}"" {string.Join(' ', arguments)}", lpLoadOrderGroup: null, lpdwTagId: 0, lpDependencies: options.Windows.Dependencies, lpServiceStartName: options.Windows.ServiceStartName, lpPassword: options.Windows.Password); if (serviceHandle.IsInvalid == true) { throw new Win32Exception(); } if (string.IsNullOrEmpty(options.Description) == false) { var desc = new ServiceDescription { lpDescription = options.Description }; var pDesc = Marshal.AllocHGlobal(Marshal.SizeOf(desc)); Marshal.StructureToPtr(desc, pDesc, false); ChangeServiceConfig2(serviceHandle, ServiceInfoLevel.SERVICE_CONFIG_DESCRIPTION, pDesc.ToPointer()); Marshal.FreeHGlobal(pDesc); } var action = new SC_ACTION { Type = (SC_ACTION_TYPE)options.Windows.FailureActionType, }; var failureAction = new SERVICE_FAILURE_ACTIONS { cActions = 1, lpsaActions = &action, dwResetPeriod = (int)TimeSpan.FromDays(1d).TotalSeconds }; if (ChangeServiceConfig2(serviceHandle, ServiceInfoLevel.SERVICE_CONFIG_FAILURE_ACTIONS, &failureAction) == false) { throw new Win32Exception(); } return serviceHandle; } private static ReadOnlySpan<char> QueryServiceFilePath(SafeServiceHandle serviceHandle) { const int ERROR_INSUFFICIENT_BUFFER = 122; if (QueryServiceConfig(serviceHandle, IntPtr.Zero, 0, out var bytesNeeded) == false) { if (Marshal.GetLastWin32Error() != ERROR_INSUFFICIENT_BUFFER) { throw new Win32Exception(); } } var buffer = Marshal.AllocHGlobal(bytesNeeded); try { if (QueryServiceConfig(serviceHandle, buffer, bytesNeeded, out _) == false) { throw new Win32Exception(); } var serviceConfig = Marshal.PtrToStructure<QUERY_SERVICE_CONFIG>(buffer); var binaryPathName = serviceConfig.lpBinaryPathName.AsSpan(); if (binaryPathName.IsEmpty) { return ReadOnlySpan<char>.Empty; } if (binaryPathName[0] == '"') { binaryPathName = binaryPathName[1..]; var index = binaryPathName.IndexOf('"'); return index < 0 ? binaryPathName : binaryPathName[..index]; } else { var index = binaryPathName.IndexOf(' '); return index < 0 ? binaryPathName : binaryPathName[..index]; } } finally { Marshal.FreeHGlobal(buffer); } } private static void StartService(SafeServiceHandle serviceHandle) { var status = new SERVICE_STATUS(); if (QueryServiceStatus(serviceHandle, ref status) == false) { throw new Win32Exception(); } if (status.dwCurrentState == ServiceState.SERVICE_RUNNING || status.dwCurrentState == ServiceState.SERVICE_START_PENDING) { return; } if (AdvApi32.StartService(serviceHandle, 0, null) == false) { throw new Win32Exception(); } } /// <summary> /// 停止并删除服务 /// </summary> [SupportedOSPlatform("windows")] public override void StopDelete() { using var managerHandle = OpenSCManager(null, null, ServiceManagerAccess.SC_MANAGER_ALL_ACCESS); if (managerHandle.IsInvalid == true) { throw new Win32Exception(); } using var serviceHandle = OpenService(managerHandle, this.Name, ServiceAccess.SERVICE_ALL_ACCESS); if (serviceHandle.IsInvalid == true) { return; } StopService(serviceHandle, TimeSpan.FromSeconds(30d)); if (DeleteService(serviceHandle) == false) { throw new Win32Exception(); } } private static unsafe void StopService(SafeServiceHandle serviceHandle, TimeSpan maxWaitTime) { var status = new SERVICE_STATUS(); if (QueryServiceStatus(serviceHandle, ref status) == false) { throw new Win32Exception(); } if (status.dwCurrentState == ServiceState.SERVICE_STOPPED) { return; } if (status.dwCurrentState != ServiceState.SERVICE_STOP_PENDING) { var failureAction = new SERVICE_FAILURE_ACTIONS(); if (ChangeServiceConfig2(serviceHandle, ServiceInfoLevel.SERVICE_CONFIG_FAILURE_ACTIONS, &failureAction) == false) { throw new Win32Exception(); } if (ControlService(serviceHandle, ServiceControl.SERVICE_CONTROL_STOP, ref status) == false) { throw new Win32Exception(); } // 这里不需要恢复SERVICE_CONFIG_FAILURE_ACTIONS，因为下面我们要删除服务 } var stopwatch = Stopwatch.StartNew(); var statusQueryDelay = TimeSpan.FromMilliseconds(100d); while (stopwatch.Elapsed < maxWaitTime) { if (status.dwCurrentState == ServiceState.SERVICE_STOPPED) { return; } Thread.Sleep(statusQueryDelay); if (QueryServiceStatus(serviceHandle, ref status) == false) { throw new Win32Exception(); } } throw new TimeoutException($"等待服务停止超过了{maxWaitTime.TotalSeconds}秒"); } /// <summary> /// 尝试获取服务的进程id /// </summary> /// <param name="processId"></param> /// <returns></returns> protected unsafe override bool TryGetProcessId(out int processId) { processId = 0; using var managerHandle = OpenSCManager(null, null, ServiceManagerAccess.SC_MANAGER_ALL_ACCESS); if (managerHandle.IsInvalid == true) { throw new Win32Exception(); } using var serviceHandle = OpenService(managerHandle, this.Name, ServiceAccess.SERVICE_ALL_ACCESS); if (serviceHandle.IsInvalid == true) { return false; } var status = new SERVICE_STATUS_PROCESS(); if (QueryServiceStatusEx(serviceHandle, SC_STATUS_TYPE.SC_STATUS_PROCESS_INFO, &status, sizeof(SERVICE_STATUS_PROCESS), out _) == false) { return false; } processId = (int)status.dwProcessId; return processId > 0; } } }

SafeServiceHandle CreateService(SafeServiceHandle managerHandle, string filePath, ServiceOptions options) {

using JWLSLMerge.Data.Attributes; namespace JWLSLMerge.Data.Models { public class PlayListItem { [Ignore] public int PlaylistItemId { get; set; } public string Label { get; set; } = null!; public int StartTrimOffsetTicks { get; set; } public int EndTrimOffsetTicks { get; set; } public int Accuracy { get; set; } public int EndAction { get; set; } public string ThumbnailFilePath { get; set; } = null!; [

get; set; } } }

Ignore] public int NewPlaylistItemId {

using JWLSLMerge.Data.Attributes; namespace JWLSLMerge.Data.Models { public class PlaylistItemMarker { [Ignore] public int PlaylistItemMarkerId { get; set; } public int PlaylistItemId { get; set; } public string Label { get; set; } = null!; public long StartTimeTicks { get; set; } public long DurationTicks { get; set; } public long EndTransitionDurationTicks { get; set; } [

get; set; } } }

Ignore] public int NewPlaylistItemMarkerId {

using System.Collections; using System.Collections.Generic; using System.Linq; using UnityEngine; using UnityEngine.UIElements; using UnityEditor.UIElements; using UnityEditor.Experimental.GraphView; using UnityEditor; using UnityEngine.Windows; using System; namespace QuestSystem.QuestEditor { public class QuestGraphSaveUtility { private QuestGraphView _targetGraphView; private List<Edge> Edges => _targetGraphView.edges.ToList(); private List<NodeQuestGraph> node => _targetGraphView.nodes.ToList().Cast<NodeQuestGraph>().ToList(); private List<NodeQuest> _cacheNodes = new List<NodeQuest>(); public static QuestGraphSaveUtility GetInstance(QuestGraphView targetGraphView) { return new QuestGraphSaveUtility { _targetGraphView = targetGraphView, }; } private void creteNodeQuestAssets(Quest Q, ref List<

int j = 0; CheckFolders(Q); string path = QuestConstants.MISIONS_FOLDER + $"/{Q.misionName}/Nodes"; string tempPath = QuestConstants.MISIONS_FOLDER + $"/{Q.misionName}/Temp"; //Move all nodes OUT to temp if (AssetDatabase.IsValidFolder(path)) { AssetDatabase.CreateFolder(QuestConstants.MISIONS_FOLDER + $"{Q.misionName}", "Temp"); var debug = AssetDatabase.MoveAsset(path, tempPath); } Debug.Log("GUID: " + AssetDatabase.CreateFolder(QuestConstants.MISIONS_FOLDER + $"/{Q.misionName}", "Nodes")); //Order by position List<NodeQuestGraph> nodeList = node.Where(node => !node.entryPoint).ToList(); foreach (var nodequest in nodeList) { //Visual part string nodeSaveName = Q.misionName + "_Node" + j; NodeQuest saveNode; //Si existe en temps bool alredyExists = false; if (alredyExists = !string.IsNullOrEmpty(AssetDatabase.AssetPathToGUID(tempPath + "/" + nodeSaveName + ".asset"))) { saveNode = AssetDatabase.LoadAssetAtPath<NodeQuest>(tempPath + "/" + nodeSaveName + ".asset"); } else { saveNode = ScriptableObject.CreateInstance<NodeQuest>(); } saveNode.GUID = nodequest.GUID; saveNode.position = nodequest.GetPosition().position; //Quest Part saveNode.isFinal = nodequest.isFinal; saveNode.extraText = nodequest.extraText; saveNode.nodeObjectives = createObjectivesFromGraph(nodequest.questObjectives); if(!alredyExists) AssetDatabase.CreateAsset(saveNode, $"{QuestConstants.MISIONS_FOLDER}/{Q.misionName}/Nodes/{nodeSaveName}.asset"); else { AssetDatabase.MoveAsset(tempPath + "/" + nodeSaveName + ".asset", path + "/" + nodeSaveName + ".asset"); } EditorUtility.SetDirty(saveNode); AssetDatabase.SaveAssets(); NodesInGraph.Add(saveNode); j++; } AssetDatabase.DeleteAsset(tempPath); } public void CheckFolders(Quest Q) { if (!AssetDatabase.IsValidFolder(QuestConstants.RESOURCES_PATH)) { AssetDatabase.CreateFolder(QuestConstants.PARENT_PATH, QuestConstants.RESOURCES_NAME); } if (!AssetDatabase.IsValidFolder(QuestConstants.MISIONS_FOLDER)) { AssetDatabase.CreateFolder(QuestConstants.RESOURCES_PATH, QuestConstants.MISIONS_NAME); } if (!AssetDatabase.IsValidFolder(QuestConstants.MISIONS_FOLDER + $"/{Q.misionName}")) { AssetDatabase.CreateFolder(QuestConstants.MISIONS_FOLDER, $"{Q.misionName}"); } } private void saveConections(Quest Q, List<NodeQuest> nodesInGraph) { var connectedPorts = Edges.Where(x => x.input.node != null).ToArray(); Q.ResetNodeLinksGraph(); foreach (NodeQuest currentNode in nodesInGraph) { currentNode.nextNode.Clear(); } for (int i = 0; i < connectedPorts.Length; i++) { var outputNode = connectedPorts[i].output.node as NodeQuestGraph; var inputNode = connectedPorts[i].input.node as NodeQuestGraph; Q.nodeLinkData.Add(new Quest.NodeLinksGraph { baseNodeGUID = outputNode.GUID, portName = connectedPorts[i].output.portName, targetNodeGUID = inputNode.GUID }); //Add to next node list NodeQuest baseNode = nodesInGraph.Find(n => n.GUID == outputNode.GUID); NodeQuest targetNode = nodesInGraph.Find(n => n.GUID == inputNode.GUID); if (targetNode != null && baseNode != null) baseNode.nextNode.Add(targetNode); } } public void SaveGraph(Quest Q) { if (!Edges.Any()) return; List<NodeQuest> NodesInGraph = new List<NodeQuest>(); // Nodes creteNodeQuestAssets(Q, ref NodesInGraph); // Conections saveConections(Q, NodesInGraph); //Last Quest parameters var startNode = node.Find(node => node.entryPoint); //Find the first node Graph Q.startDay = startNode.startDay; Q.limitDay = startNode.limitDay; Q.isMain = startNode.isMain; //Questionable var firstMisionNode = Edges.Find(x => x.output.portName == "Next"); var firstMisionNode2 = firstMisionNode.input.node as NodeQuestGraph; string GUIDfirst = firstMisionNode2.GUID; Q.firtsNode = NodesInGraph.Find(n => n.GUID == GUIDfirst); EditorUtility.SetDirty(Q); } public void LoadGraph(Quest Q) { if (Q == null) { EditorUtility.DisplayDialog("Error!!", "Quest aprece como null, revisa el scriptable object", "OK"); return; } NodeQuest[] getNodes = Resources.LoadAll<NodeQuest>($"{QuestConstants.MISIONS_NAME}/{ Q.misionName}/Nodes"); _cacheNodes = new List<NodeQuest>(getNodes); clearGraph(Q); LoadNodes(Q); ConectNodes(Q); } private void clearGraph(Quest Q) { node.Find(x => x.entryPoint).GUID = Q.nodeLinkData[0].baseNodeGUID; foreach (var node in node) { if (node.entryPoint) { var aux = node.mainContainer.Children().ToList(); var aux2 = aux[2].Children().ToList(); // C TextField misionName = aux2[0] as TextField; Toggle isMain = aux2[1] as Toggle; IntegerField startDay = aux2[2] as IntegerField; IntegerField limitDay = aux2[3] as IntegerField; misionName.value = Q.misionName; isMain.value = Q.isMain; startDay.value = Q.startDay; limitDay.value = Q.limitDay; // node.limitDay = Q.limitDay; node.startDay = Q.startDay; node.isMain = Q.isMain; node.misionName = Q.misionName; continue; } //Remove edges Edges.Where(x => x.input.node == node).ToList().ForEach(edge => _targetGraphView.RemoveElement(edge)); //Remove Node _targetGraphView.RemoveElement(node); } } private void LoadNodes(Quest Q) { foreach (var node in _cacheNodes) { var tempNode = _targetGraphView.CreateNodeQuest(node.name, Vector2.zero, node.extraText, node.isFinal); //Load node variables tempNode.GUID = node.GUID; tempNode.extraText = node.extraText; tempNode.isFinal = node.isFinal; tempNode.RefreshPorts(); if (node.nodeObjectives != null) { foreach (QuestObjective qObjective in node.nodeObjectives) { //CreateObjectives QuestObjectiveGraph objtemp = new QuestObjectiveGraph(qObjective.keyName, qObjective.maxItems, qObjective.actualItems, qObjective.description, qObjective.hiddenObjective, qObjective.autoExitOnCompleted); var deleteButton = new Button(clickEvent: () => _targetGraphView.removeQuestObjective(tempNode, objtemp)) { text = "x" }; objtemp.Add(deleteButton); var newBox = new Box(); objtemp.Add(newBox); objtemp.actualItems = qObjective.actualItems; objtemp.description = qObjective.description; objtemp.maxItems = qObjective.maxItems; objtemp.keyName = qObjective.keyName; objtemp.hiddenObjective = qObjective.hiddenObjective; objtemp.autoExitOnCompleted = qObjective.autoExitOnCompleted; tempNode.objectivesRef.Add(objtemp); tempNode.questObjectives.Add(objtemp); } } _targetGraphView.AddElement(tempNode); var nodePorts = Q.nodeLinkData.Where(x => x.baseNodeGUID == node.GUID).ToList(); nodePorts.ForEach(x => _targetGraphView.AddNextNodePort(tempNode)); } } private void ConectNodes(Quest Q) { List<NodeQuestGraph> nodeListCopy = new List<NodeQuestGraph>(node); for (int i = 0; i < nodeListCopy.Count; i++) { var conections = Q.nodeLinkData.Where(x => x.baseNodeGUID == nodeListCopy[i].GUID).ToList(); for (int j = 0; j < conections.Count(); j++) { string targetNodeGUID = conections[j].targetNodeGUID; var targetNode = nodeListCopy.Find(x => x.GUID == targetNodeGUID); LinkNodes(nodeListCopy[i].outputContainer[j].Q<Port>(), (Port)targetNode.inputContainer[0]); targetNode.SetPosition(new Rect(_cacheNodes.First(x => x.GUID == targetNodeGUID).position, new Vector2(150, 200))); } } } private void LinkNodes(Port outpor, Port inport) { var tempEdge = new Edge { output = outpor, input = inport }; tempEdge.input.Connect(tempEdge); tempEdge.output.Connect(tempEdge); _targetGraphView.Add(tempEdge); } public QuestObjective[] createObjectivesFromGraph(List<QuestObjectiveGraph> qog) { List<QuestObjective> Listaux = new List<QuestObjective>(); foreach (QuestObjectiveGraph obj in qog) { QuestObjective aux = new QuestObjective { keyName = obj.keyName, maxItems = obj.maxItems, actualItems = obj.actualItems, description = obj.description, hiddenObjective = obj.hiddenObjective, autoExitOnCompleted = obj.autoExitOnCompleted }; Listaux.Add(aux); } return Listaux.ToArray(); } } }

NodeQuest> NodesInGraph) {