beerpsi/sinmai-mods
3
3
Fork 0
Code Issues Pull Requests Packages Projects Releases 4 Wiki Activity

Compare commits

base: beerpsi:v0.1.0
Branches Tags
beerpsi:trunk
beerpsi:v0.2.0
beerpsi:v0.1.3
beerpsi:v0.1.2
beerpsi:v0.1.1
beerpsi:v0.1.0
...
compare: beerpsi:trunk
Branches Tags
beerpsi:trunk
beerpsi:v0.2.0
beerpsi:v0.1.3
beerpsi:v0.1.2
beerpsi:v0.1.1
beerpsi:v0.1.0

13 Commits
v0.1.0 ... trunk

Author SHA1 Message Date
beer-psi
7d67ab0055 fix(TouchPanel): Don't sleep if DelayMs is 0 2024-08-08 14:01:43 +07:00
beer-psi
84291635db Add back description for LooseDBTables/MoreChartFormats 2024-08-08 13:59:32 +07:00
beerpsi
74dfcfa040 Update README.md 2024-08-08 06:52:14 +00:00
beer-psi
75c36d9eb2 Fix builds 2024-08-08 13:48:31 +07:00
beer-psi
7a07ac502c remove old mods 2024-08-08 13:35:35 +07:00
beer-psi
54ff4d628f push a few more mods 2024-08-08 13:32:25 +07:00
beerpsi
6fc5af8050 fix: don't make the judgements crazy strict 2024-07-09 01:56:35 +07:00
beerpsi
26c90f5343 UnlockFrameRate 2024-06-01 19:30:03 +07:00
beerpsi
d0d3658e9a Remove some debug logging 2024-05-27 11:43:33 +07:00
beerpsi
549ebaf02f Add another SXT caveat 2024-05-27 11:03:42 +07:00
beerpsi
7d8c3d10bf Add MoreChartFormats 2024-05-27 10:59:40 +07:00
beerpsi
688836b131 Add description for LooseDBTables 2024-05-24 21:47:45 +07:00
beerpsi
1056550e9d Add loose file DB loading 2024-05-24 21:46:42 +07:00
200 changed files with 14346 additions and 485 deletions
Show Stats Expand all files Collapse all files

6
.idea/.idea.sinmai-mods/.idea/vcs.xml Normal file
View File

@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="VcsDirectoryMappings">
<mapping directory="$PROJECT_DIR$" vcs="Git" />
</component>
</project>

65
CachedDataManager/CachedDataManager.csproj
View File

@ -1,65 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props"
Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')"/>
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProjectGuid>{F1C1B6BF-626C-4F10-8672-2F9596706CA6}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>CachedDataManager</RootNamespace>
<AssemblyName>Assembly-CSharp.CachedDataManager.mm</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<LangVersion>latest</LangVersion>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<PlatformTarget>AnyCPU</PlatformTarget>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<PlatformTarget>AnyCPU</PlatformTarget>
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include="System"/>
<Reference Include="System.Core"/>
<Reference Include="System.Data"/>
<Reference Include="System.Xml"/>
<Reference Include="MonoMod">
<HintPath>..\External\MonoMod.exe</HintPath>
<Private>False</Private>
</Reference>
<Reference Include="Assembly-CSharp">
<HintPath>..\External\Assembly-CSharp.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup>
<Compile Include="Manager\MaiStudio\Serialize\patch_FilePath.cs" />
<Compile Include="Manager\patch_DataManager.cs" />
<Compile Include="SerializationCache.cs" />
<Compile Include="Properties\AssemblyInfo.cs"/>
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets"/>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>

205
CachedDataManager/Manager/patch_DataManager.cs
View File

@ -1,205 +0,0 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Xml.Serialization;
namespace Manager;
public class patch_DataManager : DataManager
{
private const string _cacheDirectory = "dataCache";
[Serializable]
[XmlType(TypeName="KeyValuePair")]
public class SerializableKeyValuePair<TK, TV>
{
public TK Key;
public TV Value;
}
private static Dictionary<string, T> LoadCacheFile<T>(string fileName)
{
if (!File.Exists(fileName))
{
return new Dictionary<string, T>();
}
using var fs = File.OpenRead(fileName);
var serializer = new XmlSerializer(typeof(List<SerializableKeyValuePair<string, T>>));
var entries = (List<SerializableKeyValuePair<string, T>>)serializer.Deserialize(fs);
return entries.ToDictionary(e => e.Key, e => e.Value);
}
private static void SaveCacheFile<T>(string destination, Dictionary<string, T> collection)
{
if (collection == null)
{
return;
}
using var fs = File.Open(destination, FileMode.Create);
var serializer = new XmlSerializer(typeof(List<SerializableKeyValuePair<string, T>>));
serializer.Serialize(
fs,
collection
.Select(kvp => new SerializableKeyValuePair<string, T> { Key = kvp.Key, Value = kvp.Value })
.ToList());
}
private static void SaveCache()
{
if (!Directory.Exists(_cacheDirectory))
{
Directory.CreateDirectory(_cacheDirectory);
}
SaveCacheFile(Path.Combine(_cacheDirectory, "RomConfigs.xml"), Cache.RomConfigs);
SaveCacheFile(Path.Combine(_cacheDirectory, "DataConfigs.xml"), Cache.DataConfigs);
SaveCacheFile(Path.Combine(_cacheDirectory, "Charas.xml"), Cache.Charas);
SaveCacheFile(Path.Combine(_cacheDirectory, "CharaAwakes.xml"), Cache.CharaAwakes);
SaveCacheFile(Path.Combine(_cacheDirectory, "CharaGenres.xml"), Cache.CharaGenres);
SaveCacheFile(Path.Combine(_cacheDirectory, "Events.xml"), Cache.Events);
SaveCacheFile(Path.Combine(_cacheDirectory, "Musics.xml"), Cache.Musics);
SaveCacheFile(Path.Combine(_cacheDirectory, "MusicGenres.xml"), Cache.MusicGenres);
SaveCacheFile(Path.Combine(_cacheDirectory, "MusicGroups.xml"), Cache.MusicGroups);
SaveCacheFile(Path.Combine(_cacheDirectory, "MusicVersions.xml"), Cache.MusicVersions);
SaveCacheFile(Path.Combine(_cacheDirectory, "MusicNameSorts.xml"), Cache.MusicNameSorts);
SaveCacheFile(Path.Combine(_cacheDirectory, "MusicClearRanks.xml"), Cache.MusicClearRanks);
SaveCacheFile(Path.Combine(_cacheDirectory, "MusicDifficultys.xml"), Cache.MusicDifficultys);
SaveCacheFile(Path.Combine(_cacheDirectory, "MusicLevels.xml"), Cache.MusicLevels);
SaveCacheFile(Path.Combine(_cacheDirectory, "TournamentMusics.xml"), Cache.TournamentMusics);
SaveCacheFile(Path.Combine(_cacheDirectory, "Courses.xml"), Cache.Courses);
SaveCacheFile(Path.Combine(_cacheDirectory, "CourseModes.xml"), Cache.CourseModes);
SaveCacheFile(Path.Combine(_cacheDirectory, "LoginBonuses.xml"), Cache.LoginBonuses);
SaveCacheFile(Path.Combine(_cacheDirectory, "Maps.xml"), Cache.Maps);
SaveCacheFile(Path.Combine(_cacheDirectory, "MapColors.xml"), Cache.MapColors);
SaveCacheFile(Path.Combine(_cacheDirectory, "MapTreasures.xml"), Cache.MapTreasures);
SaveCacheFile(Path.Combine(_cacheDirectory, "MapBonusMusics.xml"), Cache.MapBonusMusics);
SaveCacheFile(Path.Combine(_cacheDirectory, "MapOtomodachis.xml"), Cache.MapOtomodachis);
SaveCacheFile(Path.Combine(_cacheDirectory, "MapSilhouettes.xml"), Cache.MapSilhouettes);
SaveCacheFile(Path.Combine(_cacheDirectory, "MapTitles.xml"), Cache.MapTitles);
SaveCacheFile(Path.Combine(_cacheDirectory, "ItemMusics.xml"), Cache.ItemMusics);
SaveCacheFile(Path.Combine(_cacheDirectory, "Icons.xml"), Cache.Icons);
SaveCacheFile(Path.Combine(_cacheDirectory, "Plates.xml"), Cache.Plates);
SaveCacheFile(Path.Combine(_cacheDirectory, "Titles.xml"), Cache.Titles);
SaveCacheFile(Path.Combine(_cacheDirectory, "Partners.xml"), Cache.Partners);
SaveCacheFile(Path.Combine(_cacheDirectory, "Frames.xml"), Cache.Frames);
SaveCacheFile(Path.Combine(_cacheDirectory, "Tickets.xml"), Cache.Tickets);
SaveCacheFile(Path.Combine(_cacheDirectory, "CollectionTypes.xml"), Cache.CollectionTypes);
SaveCacheFile(Path.Combine(_cacheDirectory, "CollectionGenres.xml"), Cache.CollectionGenres);
SaveCacheFile(Path.Combine(_cacheDirectory, "PhotoFrames.xml"), Cache.PhotoFrames);
SaveCacheFile(Path.Combine(_cacheDirectory, "Informations.xml"), Cache.Informations);
SaveCacheFile(Path.Combine(_cacheDirectory, "Udemaes.xml"), Cache.Udemaes);
SaveCacheFile(Path.Combine(_cacheDirectory, "Classes.xml"), Cache.Classes);
SaveCacheFile(Path.Combine(_cacheDirectory, "UdemaeBosses.xml"), Cache.UdemaeBosses);
SaveCacheFile(Path.Combine(_cacheDirectory, "UdemaeSeasonEvents.xml"), Cache.UdemaeSeasonEvents);
SaveCacheFile(Path.Combine(_cacheDirectory, "UdemaeSeasonRewards.xml"), Cache.UdemaeSeasonRewards);
SaveCacheFile(Path.Combine(_cacheDirectory, "Cards.xml"), Cache.Cards);
SaveCacheFile(Path.Combine(_cacheDirectory, "CardCharas.xml"), Cache.CardCharas);
SaveCacheFile(Path.Combine(_cacheDirectory, "CardTypes.xml"), Cache.CardTypes);
SaveCacheFile(Path.Combine(_cacheDirectory, "WeekdayBonuses.xml"), Cache.WeekdayBonuses);
SaveCacheFile(Path.Combine(_cacheDirectory, "Challenges.xml"), Cache.Challenges);
SaveCacheFile(Path.Combine(_cacheDirectory, "MusicRankings.xml"), Cache.MusicRankings);
SaveCacheFile(Path.Combine(_cacheDirectory, "MusicSorts.xml"), Cache.MusicSorts);
SaveCacheFile(Path.Combine(_cacheDirectory, "LoginBonusSorts.xml"), Cache.LoginBonusSorts);
SaveCacheFile(Path.Combine(_cacheDirectory, "IconSorts.xml"), Cache.IconSorts);
SaveCacheFile(Path.Combine(_cacheDirectory, "PlateSorts.xml"), Cache.PlateSorts);
SaveCacheFile(Path.Combine(_cacheDirectory, "TitleSorts.xml"), Cache.TitleSorts);
SaveCacheFile(Path.Combine(_cacheDirectory, "PartnerSorts.xml"), Cache.PartnerSorts);
SaveCacheFile(Path.Combine(_cacheDirectory, "FrameSorts.xml"), Cache.FrameSorts);
SaveCacheFile(Path.Combine(_cacheDirectory, "TicketSorts.xml"), Cache.TicketSorts);
SaveCacheFile(Path.Combine(_cacheDirectory, "CollectionGenreSorts.xml"), Cache.CollectionGenreSorts);
SaveCacheFile(Path.Combine(_cacheDirectory, "CharaSorts.xml"), Cache.CharaSorts);
SaveCacheFile(Path.Combine(_cacheDirectory, "CharaGenreSorts.xml"), Cache.CharaGenreSorts);
}
private static extern bool orig_Deserialize<T>(string filePath, out T dsr) where T : new();
private static bool Deserialize<T>(string filePath, out T dsr) where T : new()
{
var fileName = Path.GetFileName(filePath);
var collectionName = fileName switch
{
"UdemaeBoss.xml" => "UdemaeBosses",
"Class.xml" => "Classes",
"LoginBonus.xml" => "LoginBonuses",
"ScoreRanking.xml" => "TournamentMusics",
"Holiday.xml" => "WeekdayBonuses",
_ => fileName.Replace(".xml", "s"),
};
var collectionField =
typeof(CachedDataManager.SerializationCache).GetField(collectionName, BindingFlags.Public | BindingFlags.Instance);
if (collectionField == null)
{
System.Console.WriteLine("[CachedDataManager] [WARN] Could not find suitable collection for {0} (tried name {1})", fileName, collectionName);
return orig_Deserialize(filePath, out dsr);
}
try
{
var collection = (Dictionary<string, T>)collectionField.GetValue(Cache);
if (collection == null)
{
collection = LoadCacheFile<T>(Path.Combine(_cacheDirectory, $"{collectionName}.xml"));
collectionField.SetValue(Cache, collection);
}
if (collection.TryGetValue(filePath, out dsr))
{
return true;
}
if (!orig_Deserialize(filePath, out dsr))
{
return false;
}
collection.Add(filePath, dsr);
_cacheBusted = true;
return true;
}
catch (Exception e)
{
System.Console.WriteLine("[CachedDataManager] [ERROR] Could not load from cache: {0}", e);
return orig_Deserialize(filePath, out dsr);
}
}
private extern bool orig_IsLoaded();
public new bool IsLoaded()
{
var loaded = orig_IsLoaded();
if (!loaded || !_cacheBusted)
{
return loaded;
}
try
{
SaveCache();
}
catch (Exception e)
{
System.Console.WriteLine("[CachedDataManager] [ERROR] Could not save to cache: {0}", e);
}
_cacheBusted = false;
return true;
}
private static readonly CachedDataManager.SerializationCache Cache = new();
private static bool _cacheBusted;
}

35
CachedDataManager/Properties/AssemblyInfo.cs
View File

@ -1,35 +0,0 @@
using System.Reflection;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("CachedDataManager")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("CachedDataManager")]
[assembly: AssemblyCopyright("Copyright © 2024")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("F1C1B6BF-626C-4F10-8672-2F9596706CA6")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

67
CachedDataManager/SerializationCache.cs
View File

@ -1,67 +0,0 @@
// ReSharper disable UnassignedField.Global
using System.Collections.Generic;
using Manager.MaiStudio.Serialize;
namespace CachedDataManager;
public class SerializationCache
{
public Dictionary<string, RomConfig> RomConfigs;
public Dictionary<string, DataConfig> DataConfigs;
public Dictionary<string, CharaData> Charas;
public Dictionary<string, CharaAwakeData> CharaAwakes;
public Dictionary<string, CharaGenreData> CharaGenres;
public Dictionary<string, EventData> Events;
public Dictionary<string, MusicData> Musics;
public Dictionary<string, MusicGenreData> MusicGenres;
public Dictionary<string, MusicGroupData> MusicGroups;
public Dictionary<string, MusicVersionData> MusicVersions;
public Dictionary<string, MusicNameSortData> MusicNameSorts;
public Dictionary<string, MusicClearRankData> MusicClearRanks;
public Dictionary<string, MusicDifficultyData> MusicDifficultys;
public Dictionary<string, MusicLevelData> MusicLevels;
public Dictionary<string, ScoreRankingData> TournamentMusics;
public Dictionary<string, CourseData> Courses;
public Dictionary<string, CourseModeData> CourseModes;
public Dictionary<string, LoginBonusData> LoginBonuses;
public Dictionary<string, MapData> Maps;
public Dictionary<string, MapColorData> MapColors;
public Dictionary<string, MapTreasureData> MapTreasures;
public Dictionary<string, MapBonusMusicData> MapBonusMusics;
public Dictionary<string, MapOtomodachiData> MapOtomodachis;
public Dictionary<string, MapSilhouetteData> MapSilhouettes;
public Dictionary<string, MapTitleData> MapTitles;
public Dictionary<string, ItemMusicData> ItemMusics;
public Dictionary<string, IconData> Icons;
public Dictionary<string, PlateData> Plates;
public Dictionary<string, TitleData> Titles;
public Dictionary<string, PartnerData> Partners;
public Dictionary<string, FrameData> Frames;
public Dictionary<string, TicketData> Tickets;
public Dictionary<string, CollectionTypeData> CollectionTypes;
public Dictionary<string, CollectionGenreData> CollectionGenres;
public Dictionary<string, PhotoFrameData> PhotoFrames;
public Dictionary<string, InformationData> Informations;
public Dictionary<string, UdemaeData> Udemaes;
public Dictionary<string, ClassData> Classes;
public Dictionary<string, UdemaeBossData> UdemaeBosses;
public Dictionary<string, UdemaeSeasonEventData> UdemaeSeasonEvents;
public Dictionary<string, UdemaeSeasonRewardData> UdemaeSeasonRewards;
public Dictionary<string, CardData> Cards;
public Dictionary<string, CardCharaData> CardCharas;
public Dictionary<string, CardTypeData> CardTypes;
public Dictionary<string, HolidayData> WeekdayBonuses;
public Dictionary<string, ChallengeData> Challenges;
public Dictionary<string, SerializeSortData> MusicRankings;
public Dictionary<string, SerializeSortData> MusicSorts;
public Dictionary<string, SerializeSortData> LoginBonusSorts;
public Dictionary<string, SerializeSortData> IconSorts;
public Dictionary<string, SerializeSortData> PlateSorts;
public Dictionary<string, SerializeSortData> TitleSorts;
public Dictionary<string, SerializeSortData> PartnerSorts;
public Dictionary<string, SerializeSortData> FrameSorts;
public Dictionary<string, SerializeSortData> TicketSorts;
public Dictionary<string, SerializeSortData> CollectionGenreSorts;
public Dictionary<string, SerializeSortData> CharaSorts;
public Dictionary<string, SerializeSortData> CharaGenreSorts;
}

30
DisableEncryption/DisableEncryption.csproj Normal file
View File

@ -0,0 +1,30 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net46</TargetFramework>
<LangVersion>latest</LangVersion>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<AssemblyName>Assembly-CSharp.DisableEncryption.mm</AssemblyName>
</PropertyGroup>
<ItemGroup>
<Reference Include="MonoMod">
<HintPath>..\External\MonoMod.exe</HintPath>
<Private>False</Private>
</Reference>
<Reference Include="Assembly-CSharp">
<HintPath>..\External\Assembly-CSharp.dll</HintPath>
<Private>False</Private>
</Reference>
<Reference Include="UnityEngine">
<HintPath>..\External\UnityEngine.dll</HintPath>
<Private>False</Private>
</Reference>
<Reference Include="UnityEngine.CoreModule">
<HintPath>..\External\UnityEngine.CoreModule.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
</Project>

20
DisableEncryption/Net/Packet/patch_Packet.cs Normal file
View File

@ -0,0 +1,20 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using MonoMod;
namespace Net.Packet;
public class patch_Packet : Packet
{
[MonoModIgnore]
public override PacketState Proc()
{
throw new NotImplementedException();
}
[MonoModReplace]
public new static string Obfuscator(string srcStr)
{
return srcStr;
}
}

21
DisableEncryption/Net/patch_CipherAES.cs Normal file
View File

@ -0,0 +1,21 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using MonoMod;
namespace Net;
[MonoModPatch("global::Net.CipherAES")]
public class patch_CipherAES
{
[MonoModReplace]
public static byte[] Encrypt(byte[] data)
{
return data;
}
[MonoModReplace]
public static byte[] Decrypt(byte[] data)
{
return data;
}
}

17
DisableEncryption/Net/patch_NetHttpClient.cs Normal file
View File

@ -0,0 +1,17 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;
using MonoMod;
namespace Net;
public class patch_NetHttpClient : NetHttpClient
{
[MonoModReplace]
public new static bool CheckServerHash(object sender, X509Certificate certificate, X509Chain chain,
SslPolicyErrors sslPolicyErrors)
{
return true;
}
}

17
DisableEncryption/System/Net/patch_WebHeaderCollection.cs Normal file
View File

@ -0,0 +1,17 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
namespace System.Net;
public class patch_WebHeaderCollection : WebHeaderCollection
{
public extern void orig_Add(string header, string value);
public new void Add(string header, string value)
{
if (header.ToLowerInvariant() == "mai-encoding")
{
return;
}
orig_Add(header, value);
}
}

30
DisableReboot/DisableReboot.csproj Normal file
View File

@ -0,0 +1,30 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net46</TargetFramework>
<LangVersion>latest</LangVersion>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<AssemblyName>Assembly-CSharp.DisableReboot.mm</AssemblyName>
</PropertyGroup>
<ItemGroup>
<Reference Include="MonoMod">
<HintPath>..\External\MonoMod.exe</HintPath>
<Private>False</Private>
</Reference>
<Reference Include="Assembly-CSharp">
<HintPath>..\External\Assembly-CSharp.dll</HintPath>
<Private>False</Private>
</Reference>
<Reference Include="UnityEngine">
<HintPath>..\External\UnityEngine.dll</HintPath>
<Private>False</Private>
</Reference>
<Reference Include="UnityEngine.CoreModule">
<HintPath>..\External\UnityEngine.CoreModule.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
</Project>

21
DisableReboot/Manager/Operation/patch_MaintenanceTimer.cs Normal file
View File

@ -0,0 +1,21 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using MonoMod;
namespace Manager.Operation;
public class patch_MaintenanceTimer : MaintenanceTimer
{
[MonoModReplace]
public new bool IsAutoRebootNeeded()
{
return false;
}
[MonoModReplace]
public new int GetAutoRebootSec()
{
return 86400;
}
}

39
DisableReboot/Manager/Operation/patch_SegaBootTimer.cs Normal file
View File

@ -0,0 +1,39 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using MonoMod;
namespace Manager.Operation;
public class patch_SegaBootTimer : SegaBootTimer
{
[MonoModReplace]
public new bool IsSegaBootTime()
{
return false;
}
[MonoModReplace]
public new int GetGotoSegaBootSec()
{
return 86400;
}
[MonoModReplace]
public new bool IsSegaBootNeeded()
{
return false;
}
[MonoModReplace]
public new int GetRemainingMinutes()
{
return 1440;
}
[MonoModReplace]
public new bool IsCoinAcceptable()
{
return true;
}
}

57
FixLocaleIssues/FixLocaleIssues.csproj
View File

@ -1,43 +1,14 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props"
Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')"/>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProjectGuid>{48B5F480-D749-48E9-9D26-E0E5260D95DE}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>FixLocaleIssues</RootNamespace>
<AssemblyName>Assembly-CSharp.FixLocaleIssues.mm</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<TargetFramework>net46</TargetFramework>
<LangVersion>latest</LangVersion>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<AssemblyName>Assembly-CSharp.FixLocaleIssues.mm</AssemblyName>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<PlatformTarget>AnyCPU</PlatformTarget>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<PlatformTarget>AnyCPU</PlatformTarget>
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include="System"/>
<Reference Include="System.Core"/>
<Reference Include="System.Data"/>
<Reference Include="System.Xml"/>
<Reference Include="MonoMod">
<HintPath>..\External\MonoMod.exe</HintPath>
<Private>False</Private>
@ -55,19 +26,5 @@
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup>
<Compile Include="MAI2System\patch_IniSection.cs" />
<Compile Include="Manager\patch_MA2Record.cs" />
<Compile Include="Manager\patch_SlideManager.cs" />
<Compile Include="Properties\AssemblyInfo.cs"/>
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets"/>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>

2
FixLocaleIssues/MAI2System/patch_IniSection.cs
View File

@ -18,4 +18,4 @@ class patch_IniSection : IniSection
{
return float.TryParse(_variableValue, NumberStyles.Float, CultureInfo.InvariantCulture, out value);
}
}
}

2
FixLocaleIssues/Manager/patch_MA2Record.cs
View File

@ -6,7 +6,7 @@ using MonoMod;
namespace Manager;
class patch_MA2Record : MA2Record
public class patch_MA2Record : MA2Record
{
[MonoModIgnore]
private static extern Ma2fileParamID.Def getParamIDFromRec(Ma2fileRecordID.Def rec, int index);

4
FixLocaleIssues/Manager/patch_SlideManager.cs
View File

@ -1,9 +1,7 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Text.RegularExpressions;
using System.Xml;
using MonoMod;
@ -16,7 +14,9 @@ public class patch_SlideManager : SlideManager
[MonoModIgnore]
private struct SlidePath
{
#pragma warning disable CS0649
public List<ControlPoint> Points;
#pragma warning restore CS0649
}
[MonoModIgnore]

35
FixLocaleIssues/Properties/AssemblyInfo.cs
View File

@ -1,35 +0,0 @@
using System.Reflection;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("FixLocaleIssues")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("FixLocaleIssues")]
[assembly: AssemblyCopyright("Copyright © 2024")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("48B5F480-D749-48E9-9D26-E0E5260D95DE")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

31
ImproveLoadTimes/ImproveLoadTimes.csproj Normal file
View File

@ -0,0 +1,31 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net46</TargetFramework>
<LangVersion>latest</LangVersion>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<AssemblyName>Assembly-CSharp.ImproveLoadTimes.mm</AssemblyName>
<NoWarn>CS0626</NoWarn>
</PropertyGroup>
<ItemGroup>
<Reference Include="MonoMod">
<HintPath>..\External\MonoMod.exe</HintPath>
<Private>False</Private>
</Reference>
<Reference Include="Assembly-CSharp">
<HintPath>..\External\Assembly-CSharp.dll</HintPath>
<Private>False</Private>
</Reference>
<Reference Include="UnityEngine">
<HintPath>..\External\UnityEngine.dll</HintPath>
<Private>False</Private>
</Reference>
<Reference Include="UnityEngine.CoreModule">
<HintPath>..\External\UnityEngine.CoreModule.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
</Project>

12
ImproveLoadTimes/Manager/MaiStudio/Serialize/SerializeBase.cs Normal file
View File

@ -0,0 +1,12 @@
// ReSharper disable CheckNamespace
using MonoMod;
namespace Manager.MaiStudio.Serialize;
[MonoModReplace]
[Serializable]
public class SerializeBase
{
public virtual void AddPath(string parentPath) { }
}

2
CachedDataManager/Manager/MaiStudio/Serialize/patch_FilePath.cs → ImproveLoadTimes/Manager/MaiStudio/Serialize/patch_FilePath.cs
View File

@ -17,4 +17,4 @@ public class patch_FilePath : FilePath
path = parentPath + path;
}
}
}

99
ImproveLoadTimes/Manager/patch_DataManager.cs Normal file
View File

@ -0,0 +1,99 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System.Runtime.Serialization.Formatters.Binary;
namespace Manager;
public class patch_DataManager : DataManager
{
private const string _cacheFilename = "data_cache.bin";
private static Dictionary<string, object>? _cache;
private static bool _cacheBusted;
private static extern bool orig_Deserialize<T>(string filePath, out T dsr) where T : new();
private static bool Deserialize<T>(string filePath, out T dsr) where T : new()
{
try
{
_cache ??= LoadCache(_cacheFilename);
}
catch (Exception e)
{
System.Console.WriteLine("[ImproveLoadTimes] Could not load data cache: {0}", e);
_cache ??= new Dictionary<string, object>();
}
try
{
if (_cache.TryGetValue(filePath, out var dsrObject))
{
dsr = (T)dsrObject;
return true;
}
if (!orig_Deserialize(filePath, out dsr))
{
return false;
}
// ReSharper disable once ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract
if (filePath == null || dsr == null)
{
return true;
}
_cache.Add(filePath, dsr);
_cacheBusted = true;
return true;
}
catch (Exception e)
{
System.Console.WriteLine("[ImproveLoadTimes] [ERROR] Could not load from cache: {0}", e);
return orig_Deserialize(filePath, out dsr);
}
}
private extern bool orig_IsLoaded();
public new bool IsLoaded()
{
var loaded = orig_IsLoaded();
if (!loaded || !_cacheBusted || _cache == null)
{
return loaded;
}
try
{
SaveCache(_cacheFilename, _cache);
}
catch (Exception e)
{
System.Console.WriteLine("[ImproveLoadTimes] [ERROR] Could not save to cache: {0}", e);
}
_cacheBusted = false;
return true;
}
private static Dictionary<string, object> LoadCache(string fileName)
{
if (!File.Exists(fileName))
{
return new Dictionary<string, object>();
}
System.Console.WriteLine("[ImproveLoadTimes] Loading data cache...");
using var fs = File.OpenRead(fileName);
return (Dictionary<string, object>)new BinaryFormatter().Deserialize(fs);
}
private static void SaveCache(string fileName, Dictionary<string, object> cache)
{
using var fs = File.Open(fileName, FileMode.Create, FileAccess.Write);
new BinaryFormatter().Serialize(fs, cache);
}
}

21
ImproveLoadTimes/Manager/patch_PowerOnProcess.cs Normal file
View File

@ -0,0 +1,21 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using MonoMod;
using Process;
namespace Manager;
public class patch_PowerOnProcess : PowerOnProcess
{
#pragma warning disable CS0414 // Field is assigned but its value is never used
[MonoModIgnore]
private float _waitTime;
#pragma warning restore CS0414 // Field is assigned but its value is never used
[MonoModConstructor]
public patch_PowerOnProcess(ProcessDataContainer dataContainer) : base(dataContainer)
{
_waitTime = 0f;
}
}

296
LooseDBTables/DB/DBLoader.cs Normal file
View File

@ -0,0 +1,296 @@
// ReSharper disable CheckNamespace
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
namespace DB;
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class DBLoader
{
public static void LoadAll(string dirPath)
{
AdvertiseVolumeIDEnum.LoadFromFile(Path.Combine(dirPath, "AdvertiseVolumeTableRecord.json"));
ButtonIDEnum.LoadFromFile(Path.Combine(dirPath, "ButtonTableRecord.json"));
ButtonKindIDEnum.LoadFromFile(Path.Combine(dirPath, "ButtonKindTableRecord.json"));
ButtonPosIDEnum.LoadFromFile(Path.Combine(dirPath, "ButtonPosTableRecord.json"));
ButtonTypeIDEnum.LoadFromFile(Path.Combine(dirPath, "ButtonTypeTableRecord.json"));
CharlistAbcLargeIDEnum.LoadFromFile(Path.Combine(dirPath, "CharlistAbcLargeTableRecord.json"));
CharlistAbcSmallIDEnum.LoadFromFile(Path.Combine(dirPath, "CharlistAbcSmallTableRecord.json"));
CharlistIDEnum.LoadFromFile(Path.Combine(dirPath, "CharlistTableRecord.json"));
CharlistNumIDEnum.LoadFromFile(Path.Combine(dirPath, "CharlistNumTableRecord.json"));
CharlistSymboleIDEnum.LoadFromFile(Path.Combine(dirPath, "CharlistSymboleTableRecord.json"));
CommonMessageIDEnum.LoadFromFile(Path.Combine(dirPath, "CommonMessageTableRecord.json"));
ContentBitIDEnum.LoadFromFile(Path.Combine(dirPath, "ContentBitTableRecord.json"));
DeluxcorerankrateIDEnum.LoadFromFile(Path.Combine(dirPath, "DeluxcorerankrateTableRecord.json"));
ErrorIDEnum.LoadFromFile(Path.Combine(dirPath, "ErrorTableRecord.json"));
EventModeMusicCountIDEnum.LoadFromFile(Path.Combine(dirPath, "EventModeMusicCountTableRecord.json"));
ExtendContentBitIDEnum.LoadFromFile(Path.Combine(dirPath, "ExtendContentBitTableRecord.json"));
HardInitializeTextIDEnum.LoadFromFile(Path.Combine(dirPath, "HardInitializeTextTableRecord.json"));
JvsButtonIDEnum.LoadFromFile(Path.Combine(dirPath, "JvsButtonTableRecord.json"));
JvsOutputIDEnum.LoadFromFile(Path.Combine(dirPath, "JvsOutputTableRecord.json"));
KeyCodeIDEnum.LoadFromFile(Path.Combine(dirPath, "KeyCodeTableRecord.json"));
LedBlockIDEnum.LoadFromFile(Path.Combine(dirPath, "LedBlockTableRecord.json"));
MachineGroupIDEnum.LoadFromFile(Path.Combine(dirPath, "MachineGroupTableRecord.json"));
MaintenanceInfoIDEnum.LoadFromFile(Path.Combine(dirPath, "MaintenanceInfoTableRecord.json"));
NgwordExIDEnum.LoadFromFile(Path.Combine(dirPath, "NgwordExTableRecord.json"));
NgwordJpIDEnum.LoadFromFile(Path.Combine(dirPath, "NgwordJpTableRecord.json"));
OptionAppealIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionAppealTableRecord.json"));
OptionBodybrightnessIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionBodybrightnessTableRecord.json"));
OptionBreakseIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionBreakseTableRecord.json"));
OptionCateDesignIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionCateDesignTableRecord.json"));
OptionCateGameIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionCateGameTableRecord.json"));
OptionCategoryIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionCategoryTableRecord.json"));
OptionCateJudgeIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionCateJudgeTableRecord.json"));
OptionCateSoundIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionCateSoundTableRecord.json"));
OptionCateSpeedIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionCateSpeedTableRecord.json"));
OptionCenterdisplayIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionCenterdisplayTableRecord.json"));
OptionCriticalIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionCriticalTableRecord.json"));
OptionDispbarlineIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionDispbarlineTableRecord.json"));
OptionDispchainIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionDispchainTableRecord.json"));
OptionDispjudgeIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionDispjudgeTableRecord.json"));
OptionDispjudgeposIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionDispjudgeposTableRecord.json"));
OptionDispjudgetouchposIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionDispjudgetouchposTableRecord.json"));
OptionDisprateIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionDisprateTableRecord.json"));
OptionExseIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionExseTableRecord.json"));
OptionGameholdIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionGameholdTableRecord.json"));
OptionGameoutlineIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionGameoutlineTableRecord.json"));
OptionGameslideIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionGameslideTableRecord.json"));
OptionGametapIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionGametapTableRecord.json"));
OptionHeadphonevolumeIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionHeadphonevolumeTableRecord.json"));
OptionJudgetimingIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionJudgetimingTableRecord.json"));
OptionKindIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionKindTableRecord.json"));
OptionMatchingIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionMatchingTableRecord.json"));
OptionMirrorIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionMirrorTableRecord.json"));
OptionMoviebrightnessIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionMoviebrightnessTableRecord.json"));
OptionNotesizeIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionNotesizeTableRecord.json"));
OptionNotespeedIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionNotespeedTableRecord.json"));
OptionOutframedisplayIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionOutframedisplayTableRecord.json"));
OptionRootIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionRootTableRecord.json"));
OptionSlideseIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionSlideseTableRecord.json"));
OptionSlidesizeIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionSlidesizeTableRecord.json"));
OptionSlidespeedIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionSlidespeedTableRecord.json"));
OptionStarrotateIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionStarrotateTableRecord.json"));
OptionStartypeIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionStartypeTableRecord.json"));
OptionSubmonAchiveIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionSubmonAchiveTableRecord.json"));
OptionSubmonitorIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionSubmonitorTableRecord.json"));
OptionTapSuccessSeIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionTapSuccessSeTableRecord.json"));
OptionToucheffectIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionToucheffectTableRecord.json"));
OptionTouchsizeIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionTouchsizeTableRecord.json"));
OptionTouchspeedIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionTouchspeedTableRecord.json"));
OptionTrackskipIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionTrackskipTableRecord.json"));
OptionVolumeAnswerSoundIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionVolumeAnswerSoundTableRecord.json"));
OptionVolumeIDEnum.LoadFromFile(Path.Combine(dirPath, "OptionVolumeTableRecord.json"));
PartyAdvertiseStateIDEnum.LoadFromFile(Path.Combine(dirPath, "PartyAdvertiseStateTableRecord.json"));
PartyConnectStateIDEnum.LoadFromFile(Path.Combine(dirPath, "PartyConnectStateTableRecord.json"));
PartyDeliveryCheckerErrorIDEnum.LoadFromFile(Path.Combine(dirPath, "PartyDeliveryCheckerErrorTableRecord.json"));
PartyDeliveryCheckerStateIDEnum.LoadFromFile(Path.Combine(dirPath, "PartyDeliveryCheckerStateTableRecord.json"));
PartyHeartBeatStateIDEnum.LoadFromFile(Path.Combine(dirPath, "PartyHeartBeatStateTableRecord.json"));
PartyPartyClientStateIDEnum.LoadFromFile(Path.Combine(dirPath, "PartyPartyClientStateTableRecord.json"));
PartyPartyHostStateIDEnum.LoadFromFile(Path.Combine(dirPath, "PartyPartyHostStateTableRecord.json"));
PartyPartyJoinResultIDEnum.LoadFromFile(Path.Combine(dirPath, "PartyPartyJoinResultTableRecord.json"));
PartyPartyManagerStateIDEnum.LoadFromFile(Path.Combine(dirPath, "PartyPartyManagerStateTableRecord.json"));
PartyPartyStanceIDEnum.LoadFromFile(Path.Combine(dirPath, "PartyPartyStanceTableRecord.json"));
PartySettingClientStateIDEnum.LoadFromFile(Path.Combine(dirPath, "PartySettingClientStateTableRecord.json"));
PartySettingErrorIDEnum.LoadFromFile(Path.Combine(dirPath, "PartySettingErrorTableRecord.json"));
PartySettingHostStateIDEnum.LoadFromFile(Path.Combine(dirPath, "PartySettingHostStateTableRecord.json"));
PhotoeditDateIDEnum.LoadFromFile(Path.Combine(dirPath, "PhotoeditDateTableRecord.json"));
PhotoeditLayoutIDEnum.LoadFromFile(Path.Combine(dirPath, "PhotoeditLayoutTableRecord.json"));
PhotoeditPlayerinfoIDEnum.LoadFromFile(Path.Combine(dirPath, "PhotoeditPlayerinfoTableRecord.json"));
PhotoeditSettingIDEnum.LoadFromFile(Path.Combine(dirPath, "PhotoeditSettingTableRecord.json"));
PhotoeditShopnameIDEnum.LoadFromFile(Path.Combine(dirPath, "PhotoeditShopnameTableRecord.json"));
PhotoeditStampIDEnum.LoadFromFile(Path.Combine(dirPath, "PhotoeditStampTableRecord.json"));
PlayComboflagIDEnum.LoadFromFile(Path.Combine(dirPath, "PlayComboflagTableRecord.json"));
PlaystatusTabIDEnum.LoadFromFile(Path.Combine(dirPath, "PlaystatusTabTableRecord.json"));
PlaySyncflagIDEnum.LoadFromFile(Path.Combine(dirPath, "PlaySyncflagTableRecord.json"));
RateColorIDEnum.LoadFromFile(Path.Combine(dirPath, "RateColorTableRecord.json"));
RatingTableIDEnum.LoadFromFile(Path.Combine(dirPath, "RatingTableTableRecord.json"));
SortMusicIDEnum.LoadFromFile(Path.Combine(dirPath, "SortMusicTableRecord.json"));
SortRootIDEnum.LoadFromFile(Path.Combine(dirPath, "SortRootTableRecord.json"));
SortTabIDEnum.LoadFromFile(Path.Combine(dirPath, "SortTabTableRecord.json"));
SystemInitializeTextIDEnum.LoadFromFile(Path.Combine(dirPath, "SystemInitializeTextTableRecord.json"));
TestmodeAccountingIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeAccountingTableRecord.json"));
TestmodeAimeReadIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeAimeReadTableRecord.json"));
TestmodeBackupclearConfirmIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeBackupclearConfirmTableRecord.json"));
TestmodeBackupclearDoneIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeBackupclearDoneTableRecord.json"));
TestmodeBackupclearIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeBackupclearTableRecord.json"));
TestmodeBookkeep1IDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeBookkeep1TableRecord.json"));
TestmodeBookkeep2IDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeBookkeep2TableRecord.json"));
TestmodeBookkeep3IDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeBookkeep3TableRecord.json"));
TestmodeCameraIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeCameraTableRecord.json"));
TestmodeCloseChangedIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeCloseChangedTableRecord.json"));
TestmodeCloseConfirmIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeCloseConfirmTableRecord.json"));
TestmodeCloseIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeCloseTableRecord.json"));
TestmodeDebugEventsetIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeDebugEventsetTableRecord.json"));
TestmodeDebugInisetIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeDebugInisetTableRecord.json"));
TestmodeDebugLedIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeDebugLedTableRecord.json"));
TestmodeDebugSoundtestIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeDebugSoundtestTableRecord.json"));
TestmodeDownloadIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeDownloadTableRecord.json"));
TestmodeEmoneyAuthIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeEmoneyAuthTableRecord.json"));
TestmodeEmoneyIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeEmoneyTableRecord.json"));
TestmodeEmoneyRemoveIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeEmoneyRemoveTableRecord.json"));
TestmodeGamesettingIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeGamesettingTableRecord.json"));
TestmodeGenericIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeGenericTableRecord.json"));
TestmodeInputIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeInputTableRecord.json"));
TestmodeMonitorIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeMonitorTableRecord.json"));
TestmodeNetworkIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeNetworkTableRecord.json"));
TestmodeOutputIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeOutputTableRecord.json"));
TestmodeRootIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeRootTableRecord.json"));
TestmodeSystemInfo1IDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeSystemInfo1TableRecord.json"));
TestmodeSystemInfo2IDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeSystemInfo2TableRecord.json"));
TestmodeSystemtestIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeSystemtestTableRecord.json"));
TestmodeTouchpanel1pIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeTouchpanel1pTableRecord.json"));
TestmodeTouchpanel2pIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeTouchpanel2pTableRecord.json"));
TestmodeTouchpanelIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeTouchpanelTableRecord.json"));
TestmodeVfdIDEnum.LoadFromFile(Path.Combine(dirPath, "TestmodeVfdTableRecord.json"));
VsghostnpcIDEnum.LoadFromFile(Path.Combine(dirPath, "VsghostnpcTableRecord.json"));
WindowKindIDEnum.LoadFromFile(Path.Combine(dirPath, "WindowKindTableRecord.json"));
WindowMessageIDEnum.LoadFromFile(Path.Combine(dirPath, "WindowMessageTableRecord.json"));
WindowPositionIDEnum.LoadFromFile(Path.Combine(dirPath, "WindowPositionTableRecord.json"));
WindowSizeIDEnum.LoadFromFile(Path.Combine(dirPath, "WindowSizeTableRecord.json"));
}
public static void DumpAll(string dirPath)
{
AdvertiseVolumeIDEnum.DumpToFile(Path.Combine(dirPath, "AdvertiseVolumeTableRecord.json"));
ButtonIDEnum.DumpToFile(Path.Combine(dirPath, "ButtonTableRecord.json"));
ButtonKindIDEnum.DumpToFile(Path.Combine(dirPath, "ButtonKindTableRecord.json"));
ButtonPosIDEnum.DumpToFile(Path.Combine(dirPath, "ButtonPosTableRecord.json"));
ButtonTypeIDEnum.DumpToFile(Path.Combine(dirPath, "ButtonTypeTableRecord.json"));
CharlistAbcLargeIDEnum.DumpToFile(Path.Combine(dirPath, "CharlistAbcLargeTableRecord.json"));
CharlistAbcSmallIDEnum.DumpToFile(Path.Combine(dirPath, "CharlistAbcSmallTableRecord.json"));
CharlistIDEnum.DumpToFile(Path.Combine(dirPath, "CharlistTableRecord.json"));
CharlistNumIDEnum.DumpToFile(Path.Combine(dirPath, "CharlistNumTableRecord.json"));
CharlistSymboleIDEnum.DumpToFile(Path.Combine(dirPath, "CharlistSymboleTableRecord.json"));
CommonMessageIDEnum.DumpToFile(Path.Combine(dirPath, "CommonMessageTableRecord.json"));
ContentBitIDEnum.DumpToFile(Path.Combine(dirPath, "ContentBitTableRecord.json"));
DeluxcorerankrateIDEnum.DumpToFile(Path.Combine(dirPath, "DeluxcorerankrateTableRecord.json"));
ErrorIDEnum.DumpToFile(Path.Combine(dirPath, "ErrorTableRecord.json"));
EventModeMusicCountIDEnum.DumpToFile(Path.Combine(dirPath, "EventModeMusicCountTableRecord.json"));
ExtendContentBitIDEnum.DumpToFile(Path.Combine(dirPath, "ExtendContentBitTableRecord.json"));
HardInitializeTextIDEnum.DumpToFile(Path.Combine(dirPath, "HardInitializeTextTableRecord.json"));
JvsButtonIDEnum.DumpToFile(Path.Combine(dirPath, "JvsButtonTableRecord.json"));
JvsOutputIDEnum.DumpToFile(Path.Combine(dirPath, "JvsOutputTableRecord.json"));
KeyCodeIDEnum.DumpToFile(Path.Combine(dirPath, "KeyCodeTableRecord.json"));
LedBlockIDEnum.DumpToFile(Path.Combine(dirPath, "LedBlockTableRecord.json"));
MachineGroupIDEnum.DumpToFile(Path.Combine(dirPath, "MachineGroupTableRecord.json"));
MaintenanceInfoIDEnum.DumpToFile(Path.Combine(dirPath, "MaintenanceInfoTableRecord.json"));
NgwordExIDEnum.DumpToFile(Path.Combine(dirPath, "NgwordExTableRecord.json"));
NgwordJpIDEnum.DumpToFile(Path.Combine(dirPath, "NgwordJpTableRecord.json"));
OptionAppealIDEnum.DumpToFile(Path.Combine(dirPath, "OptionAppealTableRecord.json"));
OptionBodybrightnessIDEnum.DumpToFile(Path.Combine(dirPath, "OptionBodybrightnessTableRecord.json"));
OptionBreakseIDEnum.DumpToFile(Path.Combine(dirPath, "OptionBreakseTableRecord.json"));
OptionCateDesignIDEnum.DumpToFile(Path.Combine(dirPath, "OptionCateDesignTableRecord.json"));
OptionCateGameIDEnum.DumpToFile(Path.Combine(dirPath, "OptionCateGameTableRecord.json"));
OptionCategoryIDEnum.DumpToFile(Path.Combine(dirPath, "OptionCategoryTableRecord.json"));
OptionCateJudgeIDEnum.DumpToFile(Path.Combine(dirPath, "OptionCateJudgeTableRecord.json"));
OptionCateSoundIDEnum.DumpToFile(Path.Combine(dirPath, "OptionCateSoundTableRecord.json"));
OptionCateSpeedIDEnum.DumpToFile(Path.Combine(dirPath, "OptionCateSpeedTableRecord.json"));
OptionCenterdisplayIDEnum.DumpToFile(Path.Combine(dirPath, "OptionCenterdisplayTableRecord.json"));
OptionCriticalIDEnum.DumpToFile(Path.Combine(dirPath, "OptionCriticalTableRecord.json"));
OptionDispbarlineIDEnum.DumpToFile(Path.Combine(dirPath, "OptionDispbarlineTableRecord.json"));
OptionDispchainIDEnum.DumpToFile(Path.Combine(dirPath, "OptionDispchainTableRecord.json"));
OptionDispjudgeIDEnum.DumpToFile(Path.Combine(dirPath, "OptionDispjudgeTableRecord.json"));
OptionDispjudgeposIDEnum.DumpToFile(Path.Combine(dirPath, "OptionDispjudgeposTableRecord.json"));
OptionDispjudgetouchposIDEnum.DumpToFile(Path.Combine(dirPath, "OptionDispjudgetouchposTableRecord.json"));
OptionDisprateIDEnum.DumpToFile(Path.Combine(dirPath, "OptionDisprateTableRecord.json"));
OptionExseIDEnum.DumpToFile(Path.Combine(dirPath, "OptionExseTableRecord.json"));
OptionGameholdIDEnum.DumpToFile(Path.Combine(dirPath, "OptionGameholdTableRecord.json"));
OptionGameoutlineIDEnum.DumpToFile(Path.Combine(dirPath, "OptionGameoutlineTableRecord.json"));
OptionGameslideIDEnum.DumpToFile(Path.Combine(dirPath, "OptionGameslideTableRecord.json"));
OptionGametapIDEnum.DumpToFile(Path.Combine(dirPath, "OptionGametapTableRecord.json"));
OptionHeadphonevolumeIDEnum.DumpToFile(Path.Combine(dirPath, "OptionHeadphonevolumeTableRecord.json"));
OptionJudgetimingIDEnum.DumpToFile(Path.Combine(dirPath, "OptionJudgetimingTableRecord.json"));
OptionKindIDEnum.DumpToFile(Path.Combine(dirPath, "OptionKindTableRecord.json"));
OptionMatchingIDEnum.DumpToFile(Path.Combine(dirPath, "OptionMatchingTableRecord.json"));
OptionMirrorIDEnum.DumpToFile(Path.Combine(dirPath, "OptionMirrorTableRecord.json"));
OptionMoviebrightnessIDEnum.DumpToFile(Path.Combine(dirPath, "OptionMoviebrightnessTableRecord.json"));
OptionNotesizeIDEnum.DumpToFile(Path.Combine(dirPath, "OptionNotesizeTableRecord.json"));
OptionNotespeedIDEnum.DumpToFile(Path.Combine(dirPath, "OptionNotespeedTableRecord.json"));
OptionOutframedisplayIDEnum.DumpToFile(Path.Combine(dirPath, "OptionOutframedisplayTableRecord.json"));
OptionRootIDEnum.DumpToFile(Path.Combine(dirPath, "OptionRootTableRecord.json"));
OptionSlideseIDEnum.DumpToFile(Path.Combine(dirPath, "OptionSlideseTableRecord.json"));
OptionSlidesizeIDEnum.DumpToFile(Path.Combine(dirPath, "OptionSlidesizeTableRecord.json"));
OptionSlidespeedIDEnum.DumpToFile(Path.Combine(dirPath, "OptionSlidespeedTableRecord.json"));
OptionStarrotateIDEnum.DumpToFile(Path.Combine(dirPath, "OptionStarrotateTableRecord.json"));
OptionStartypeIDEnum.DumpToFile(Path.Combine(dirPath, "OptionStartypeTableRecord.json"));
OptionSubmonAchiveIDEnum.DumpToFile(Path.Combine(dirPath, "OptionSubmonAchiveTableRecord.json"));
OptionSubmonitorIDEnum.DumpToFile(Path.Combine(dirPath, "OptionSubmonitorTableRecord.json"));
OptionTapSuccessSeIDEnum.DumpToFile(Path.Combine(dirPath, "OptionTapSuccessSeTableRecord.json"));
OptionToucheffectIDEnum.DumpToFile(Path.Combine(dirPath, "OptionToucheffectTableRecord.json"));
OptionTouchsizeIDEnum.DumpToFile(Path.Combine(dirPath, "OptionTouchsizeTableRecord.json"));
OptionTouchspeedIDEnum.DumpToFile(Path.Combine(dirPath, "OptionTouchspeedTableRecord.json"));
OptionTrackskipIDEnum.DumpToFile(Path.Combine(dirPath, "OptionTrackskipTableRecord.json"));
OptionVolumeAnswerSoundIDEnum.DumpToFile(Path.Combine(dirPath, "OptionVolumeAnswerSoundTableRecord.json"));
OptionVolumeIDEnum.DumpToFile(Path.Combine(dirPath, "OptionVolumeTableRecord.json"));
PartyAdvertiseStateIDEnum.DumpToFile(Path.Combine(dirPath, "PartyAdvertiseStateTableRecord.json"));
PartyConnectStateIDEnum.DumpToFile(Path.Combine(dirPath, "PartyConnectStateTableRecord.json"));
PartyDeliveryCheckerErrorIDEnum.DumpToFile(Path.Combine(dirPath, "PartyDeliveryCheckerErrorTableRecord.json"));
PartyDeliveryCheckerStateIDEnum.DumpToFile(Path.Combine(dirPath, "PartyDeliveryCheckerStateTableRecord.json"));
PartyHeartBeatStateIDEnum.DumpToFile(Path.Combine(dirPath, "PartyHeartBeatStateTableRecord.json"));
PartyPartyClientStateIDEnum.DumpToFile(Path.Combine(dirPath, "PartyPartyClientStateTableRecord.json"));
PartyPartyHostStateIDEnum.DumpToFile(Path.Combine(dirPath, "PartyPartyHostStateTableRecord.json"));
PartyPartyJoinResultIDEnum.DumpToFile(Path.Combine(dirPath, "PartyPartyJoinResultTableRecord.json"));
PartyPartyManagerStateIDEnum.DumpToFile(Path.Combine(dirPath, "PartyPartyManagerStateTableRecord.json"));
PartyPartyStanceIDEnum.DumpToFile(Path.Combine(dirPath, "PartyPartyStanceTableRecord.json"));
PartySettingClientStateIDEnum.DumpToFile(Path.Combine(dirPath, "PartySettingClientStateTableRecord.json"));
PartySettingErrorIDEnum.DumpToFile(Path.Combine(dirPath, "PartySettingErrorTableRecord.json"));
PartySettingHostStateIDEnum.DumpToFile(Path.Combine(dirPath, "PartySettingHostStateTableRecord.json"));
PhotoeditDateIDEnum.DumpToFile(Path.Combine(dirPath, "PhotoeditDateTableRecord.json"));
PhotoeditLayoutIDEnum.DumpToFile(Path.Combine(dirPath, "PhotoeditLayoutTableRecord.json"));
PhotoeditPlayerinfoIDEnum.DumpToFile(Path.Combine(dirPath, "PhotoeditPlayerinfoTableRecord.json"));
PhotoeditSettingIDEnum.DumpToFile(Path.Combine(dirPath, "PhotoeditSettingTableRecord.json"));
PhotoeditShopnameIDEnum.DumpToFile(Path.Combine(dirPath, "PhotoeditShopnameTableRecord.json"));
PhotoeditStampIDEnum.DumpToFile(Path.Combine(dirPath, "PhotoeditStampTableRecord.json"));
PlayComboflagIDEnum.DumpToFile(Path.Combine(dirPath, "PlayComboflagTableRecord.json"));
PlaystatusTabIDEnum.DumpToFile(Path.Combine(dirPath, "PlaystatusTabTableRecord.json"));
PlaySyncflagIDEnum.DumpToFile(Path.Combine(dirPath, "PlaySyncflagTableRecord.json"));
RateColorIDEnum.DumpToFile(Path.Combine(dirPath, "RateColorTableRecord.json"));
RatingTableIDEnum.DumpToFile(Path.Combine(dirPath, "RatingTableTableRecord.json"));
SortMusicIDEnum.DumpToFile(Path.Combine(dirPath, "SortMusicTableRecord.json"));
SortRootIDEnum.DumpToFile(Path.Combine(dirPath, "SortRootTableRecord.json"));
SortTabIDEnum.DumpToFile(Path.Combine(dirPath, "SortTabTableRecord.json"));
SystemInitializeTextIDEnum.DumpToFile(Path.Combine(dirPath, "SystemInitializeTextTableRecord.json"));
TestmodeAccountingIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeAccountingTableRecord.json"));
TestmodeAimeReadIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeAimeReadTableRecord.json"));
TestmodeBackupclearConfirmIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeBackupclearConfirmTableRecord.json"));
TestmodeBackupclearDoneIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeBackupclearDoneTableRecord.json"));
TestmodeBackupclearIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeBackupclearTableRecord.json"));
TestmodeBookkeep1IDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeBookkeep1TableRecord.json"));
TestmodeBookkeep2IDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeBookkeep2TableRecord.json"));
TestmodeBookkeep3IDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeBookkeep3TableRecord.json"));
TestmodeCameraIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeCameraTableRecord.json"));
TestmodeCloseChangedIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeCloseChangedTableRecord.json"));
TestmodeCloseConfirmIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeCloseConfirmTableRecord.json"));
TestmodeCloseIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeCloseTableRecord.json"));
TestmodeDebugEventsetIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeDebugEventsetTableRecord.json"));
TestmodeDebugInisetIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeDebugInisetTableRecord.json"));
TestmodeDebugLedIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeDebugLedTableRecord.json"));
TestmodeDebugSoundtestIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeDebugSoundtestTableRecord.json"));
TestmodeDownloadIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeDownloadTableRecord.json"));
TestmodeEmoneyAuthIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeEmoneyAuthTableRecord.json"));
TestmodeEmoneyIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeEmoneyTableRecord.json"));
TestmodeEmoneyRemoveIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeEmoneyRemoveTableRecord.json"));
TestmodeGamesettingIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeGamesettingTableRecord.json"));
TestmodeGenericIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeGenericTableRecord.json"));
TestmodeInputIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeInputTableRecord.json"));
TestmodeMonitorIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeMonitorTableRecord.json"));
TestmodeNetworkIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeNetworkTableRecord.json"));
TestmodeOutputIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeOutputTableRecord.json"));
TestmodeRootIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeRootTableRecord.json"));
TestmodeSystemInfo1IDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeSystemInfo1TableRecord.json"));
TestmodeSystemInfo2IDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeSystemInfo2TableRecord.json"));
TestmodeSystemtestIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeSystemtestTableRecord.json"));
TestmodeTouchpanel1pIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeTouchpanel1pTableRecord.json"));
TestmodeTouchpanel2pIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeTouchpanel2pTableRecord.json"));
TestmodeTouchpanelIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeTouchpanelTableRecord.json"));
TestmodeVfdIDEnum.DumpToFile(Path.Combine(dirPath, "TestmodeVfdTableRecord.json"));
VsghostnpcIDEnum.DumpToFile(Path.Combine(dirPath, "VsghostnpcTableRecord.json"));
WindowKindIDEnum.DumpToFile(Path.Combine(dirPath, "WindowKindTableRecord.json"));
WindowMessageIDEnum.DumpToFile(Path.Combine(dirPath, "WindowMessageTableRecord.json"));
WindowPositionIDEnum.DumpToFile(Path.Combine(dirPath, "WindowPositionTableRecord.json"));
WindowSizeIDEnum.DumpToFile(Path.Combine(dirPath, "WindowSizeTableRecord.json"));
}
}

78
LooseDBTables/DB/patch_AdvertiseVolumeIDEnum.cs Normal file
View File

@ -0,0 +1,78 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class AdvertiseVolumeIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static AdvertiseVolumeTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableAdvertiseVolumeTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.Int32 Volume;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_AdvertiseVolumeIDEnum : AdvertiseVolumeIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableAdvertiseVolumeTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new AdvertiseVolumeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, Volume = (System.Int32)src[i].Volume, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableAdvertiseVolumeTableRecord>() {
records = new SerializableAdvertiseVolumeTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableAdvertiseVolumeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, Volume = (System.Int32)src[i].Volume, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

79
LooseDBTables/DB/patch_ButtonIDEnum.cs Normal file
View File

@ -0,0 +1,79 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class ButtonIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static ButtonTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableButtonTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.Int32 Kind;
public System.Int32 Type;
public System.Int32 Name;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_ButtonIDEnum : ButtonIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableButtonTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new ButtonTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Kind = (DB.ButtonKindID)src[i].Kind, Type = (DB.ButtonTypeID)src[i].Type, Name = (System.Int32)src[i].Name, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableButtonTableRecord>() {
records = new SerializableButtonTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableButtonTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Kind = (int)src[i].Kind, Type = (int)src[i].Type, Name = (System.Int32)src[i].Name, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

77
LooseDBTables/DB/patch_ButtonKindIDEnum.cs Normal file
View File

@ -0,0 +1,77 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class ButtonKindIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static ButtonKindTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableButtonKindTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_ButtonKindIDEnum : ButtonKindIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableButtonKindTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new ButtonKindTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableButtonKindTableRecord>() {
records = new SerializableButtonKindTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableButtonKindTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

77
LooseDBTables/DB/patch_ButtonPosIDEnum.cs Normal file
View File

@ -0,0 +1,77 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class ButtonPosIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static ButtonPosTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableButtonPosTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_ButtonPosIDEnum : ButtonPosIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableButtonPosTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new ButtonPosTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableButtonPosTableRecord>() {
records = new SerializableButtonPosTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableButtonPosTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

77
LooseDBTables/DB/patch_ButtonTypeIDEnum.cs Normal file
View File

@ -0,0 +1,77 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class ButtonTypeIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static ButtonTypeTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableButtonTypeTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_ButtonTypeIDEnum : ButtonTypeIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableButtonTypeTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new ButtonTypeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableButtonTypeTableRecord>() {
records = new SerializableButtonTypeTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableButtonTypeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

77
LooseDBTables/DB/patch_CharlistAbcLargeIDEnum.cs Normal file
View File

@ -0,0 +1,77 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class CharlistAbcLargeIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static CharlistAbcLargeTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableCharlistAbcLargeTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_CharlistAbcLargeIDEnum : CharlistAbcLargeIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableCharlistAbcLargeTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new CharlistAbcLargeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableCharlistAbcLargeTableRecord>() {
records = new SerializableCharlistAbcLargeTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableCharlistAbcLargeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

77
LooseDBTables/DB/patch_CharlistAbcSmallIDEnum.cs Normal file
View File

@ -0,0 +1,77 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class CharlistAbcSmallIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static CharlistAbcSmallTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableCharlistAbcSmallTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_CharlistAbcSmallIDEnum : CharlistAbcSmallIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableCharlistAbcSmallTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new CharlistAbcSmallTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableCharlistAbcSmallTableRecord>() {
records = new SerializableCharlistAbcSmallTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableCharlistAbcSmallTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

77
LooseDBTables/DB/patch_CharlistIDEnum.cs Normal file
View File

@ -0,0 +1,77 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class CharlistIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static CharlistTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableCharlistTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_CharlistIDEnum : CharlistIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableCharlistTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new CharlistTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableCharlistTableRecord>() {
records = new SerializableCharlistTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableCharlistTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

77
LooseDBTables/DB/patch_CharlistNumIDEnum.cs Normal file
View File

@ -0,0 +1,77 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class CharlistNumIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static CharlistNumTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableCharlistNumTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_CharlistNumIDEnum : CharlistNumIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableCharlistNumTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new CharlistNumTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableCharlistNumTableRecord>() {
records = new SerializableCharlistNumTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableCharlistNumTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

77
LooseDBTables/DB/patch_CharlistSymboleIDEnum.cs Normal file
View File

@ -0,0 +1,77 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class CharlistSymboleIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static CharlistSymboleTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableCharlistSymboleTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_CharlistSymboleIDEnum : CharlistSymboleIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableCharlistSymboleTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new CharlistSymboleTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableCharlistSymboleTableRecord>() {
records = new SerializableCharlistSymboleTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableCharlistSymboleTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

78
LooseDBTables/DB/patch_CommonMessageIDEnum.cs Normal file
View File

@ -0,0 +1,78 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class CommonMessageIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static CommonMessageTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableCommonMessageTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_CommonMessageIDEnum : CommonMessageIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableCommonMessageTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new CommonMessageTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableCommonMessageTableRecord>() {
records = new SerializableCommonMessageTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableCommonMessageTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

78
LooseDBTables/DB/patch_ContentBitIDEnum.cs Normal file
View File

@ -0,0 +1,78 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class ContentBitIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static ContentBitTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableContentBitTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.Boolean isGuestIgnore;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_ContentBitIDEnum : ContentBitIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableContentBitTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new ContentBitTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, isGuestIgnore = (System.Boolean)src[i].isGuestIgnore, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableContentBitTableRecord>() {
records = new SerializableContentBitTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableContentBitTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, isGuestIgnore = (System.Boolean)src[i].isGuestIgnore, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

78
LooseDBTables/DB/patch_DeluxcorerankrateIDEnum.cs Normal file
View File

@ -0,0 +1,78 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class DeluxcorerankrateIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static DeluxcorerankrateTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableDeluxcorerankrateTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.Int32 Achieve;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_DeluxcorerankrateIDEnum : DeluxcorerankrateIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableDeluxcorerankrateTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new DeluxcorerankrateTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, Achieve = (System.Int32)src[i].Achieve, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableDeluxcorerankrateTableRecord>() {
records = new SerializableDeluxcorerankrateTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableDeluxcorerankrateTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, Achieve = (System.Int32)src[i].Achieve, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

80
LooseDBTables/DB/patch_ErrorIDEnum.cs Normal file
View File

@ -0,0 +1,80 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class ErrorIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static ErrorTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableErrorTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.Boolean isWarning;
public System.Boolean isFirmUpdate;
public System.Int32 Code;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_ErrorIDEnum : ErrorIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableErrorTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new ErrorTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, isWarning = (System.Boolean)src[i].isWarning, isFirmUpdate = (System.Boolean)src[i].isFirmUpdate, Code = (System.Int32)src[i].Code, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableErrorTableRecord>() {
records = new SerializableErrorTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableErrorTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, isWarning = (System.Boolean)src[i].isWarning, isFirmUpdate = (System.Boolean)src[i].isFirmUpdate, Code = (System.Int32)src[i].Code, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

78
LooseDBTables/DB/patch_EventModeMusicCountIDEnum.cs Normal file
View File

@ -0,0 +1,78 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class EventModeMusicCountIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static EventModeMusicCountTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableEventModeMusicCountTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.Int32 Track;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_EventModeMusicCountIDEnum : EventModeMusicCountIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableEventModeMusicCountTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new EventModeMusicCountTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, Track = (System.Int32)src[i].Track, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableEventModeMusicCountTableRecord>() {
records = new SerializableEventModeMusicCountTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableEventModeMusicCountTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, Track = (System.Int32)src[i].Track, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

77
LooseDBTables/DB/patch_ExtendContentBitIDEnum.cs Normal file
View File

@ -0,0 +1,77 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class ExtendContentBitIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static ExtendContentBitTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableExtendContentBitTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_ExtendContentBitIDEnum : ExtendContentBitIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableExtendContentBitTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new ExtendContentBitTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableExtendContentBitTableRecord>() {
records = new SerializableExtendContentBitTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableExtendContentBitTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

77
LooseDBTables/DB/patch_HardInitializeTextIDEnum.cs Normal file
View File

@ -0,0 +1,77 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class HardInitializeTextIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static HardInitializeTextTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableHardInitializeTextTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_HardInitializeTextIDEnum : HardInitializeTextIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableHardInitializeTextTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new HardInitializeTextTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableHardInitializeTextTableRecord>() {
records = new SerializableHardInitializeTextTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableHardInitializeTextTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_JvsButtonIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class JvsButtonIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static JvsButtonTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableJvsButtonTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.Int32 JvsPlayer;
public System.String InputIDName;
public System.Int32 SubstituteKey;
public System.Int32 Invert;
public System.Int32 System;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_JvsButtonIDEnum : JvsButtonIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableJvsButtonTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new JvsButtonTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, JvsPlayer = (System.Int32)src[i].JvsPlayer, InputIDName = (System.String)src[i].InputIDName, SubstituteKey = (DB.KeyCodeID)src[i].SubstituteKey, Invert = (System.Int32)src[i].Invert, System = (System.Int32)src[i].System, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableJvsButtonTableRecord>() {
records = new SerializableJvsButtonTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableJvsButtonTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, JvsPlayer = (System.Int32)src[i].JvsPlayer, InputIDName = (System.String)src[i].InputIDName, SubstituteKey = (int)src[i].SubstituteKey, Invert = (System.Int32)src[i].Invert, System = (System.Int32)src[i].System, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

78
LooseDBTables/DB/patch_JvsOutputIDEnum.cs Normal file
View File

@ -0,0 +1,78 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class JvsOutputIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static JvsOutputTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableJvsOutputTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String OutputIDName;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_JvsOutputIDEnum : JvsOutputIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableJvsOutputTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new JvsOutputTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, OutputIDName = (System.String)src[i].OutputIDName, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableJvsOutputTableRecord>() {
records = new SerializableJvsOutputTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableJvsOutputTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, OutputIDName = (System.String)src[i].OutputIDName, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

78
LooseDBTables/DB/patch_KeyCodeIDEnum.cs Normal file
View File

@ -0,0 +1,78 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class KeyCodeIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static KeyCodeTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableKeyCodeTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.Int32 Value;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_KeyCodeIDEnum : KeyCodeIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableKeyCodeTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new KeyCodeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, Value = (System.Int32)src[i].Value, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableKeyCodeTableRecord>() {
records = new SerializableKeyCodeTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableKeyCodeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, Value = (System.Int32)src[i].Value, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

81
LooseDBTables/DB/patch_LedBlockIDEnum.cs Normal file
View File

@ -0,0 +1,81 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class LedBlockIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static LedBlockTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableLedBlockTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.Int32 LedbdID;
public System.Int32 Playerindex;
public System.Boolean isJvs;
public System.Boolean isFet;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_LedBlockIDEnum : LedBlockIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableLedBlockTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new LedBlockTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, LedbdID = (System.Int32)src[i].LedbdID, Playerindex = (System.Int32)src[i].Playerindex, isJvs = (System.Boolean)src[i].isJvs, isFet = (System.Boolean)src[i].isFet, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableLedBlockTableRecord>() {
records = new SerializableLedBlockTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableLedBlockTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, LedbdID = (System.Int32)src[i].LedbdID, Playerindex = (System.Int32)src[i].Playerindex, isJvs = (System.Boolean)src[i].isJvs, isFet = (System.Boolean)src[i].isFet, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

77
LooseDBTables/DB/patch_MachineGroupIDEnum.cs Normal file
View File

@ -0,0 +1,77 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class MachineGroupIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static MachineGroupTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableMachineGroupTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_MachineGroupIDEnum : MachineGroupIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableMachineGroupTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new MachineGroupTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableMachineGroupTableRecord>() {
records = new SerializableMachineGroupTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableMachineGroupTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

77
LooseDBTables/DB/patch_MaintenanceInfoIDEnum.cs Normal file
View File

@ -0,0 +1,77 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class MaintenanceInfoIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static MaintenanceInfoTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableMaintenanceInfoTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_MaintenanceInfoIDEnum : MaintenanceInfoIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableMaintenanceInfoTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new MaintenanceInfoTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableMaintenanceInfoTableRecord>() {
records = new SerializableMaintenanceInfoTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableMaintenanceInfoTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

77
LooseDBTables/DB/patch_NgwordExIDEnum.cs Normal file
View File

@ -0,0 +1,77 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class NgwordExIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static NgwordExTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableNgwordExTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_NgwordExIDEnum : NgwordExIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableNgwordExTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new NgwordExTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableNgwordExTableRecord>() {
records = new SerializableNgwordExTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableNgwordExTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

77
LooseDBTables/DB/patch_NgwordJpIDEnum.cs Normal file
View File

@ -0,0 +1,77 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class NgwordJpIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static NgwordJpTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableNgwordJpTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_NgwordJpIDEnum : NgwordJpIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableNgwordJpTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new NgwordJpTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableNgwordJpTableRecord>() {
records = new SerializableNgwordJpTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableNgwordJpTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_OptionAppealIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionAppealIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionAppealTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionAppealTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionAppealIDEnum : OptionAppealIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionAppealTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionAppealTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionAppealTableRecord>() {
records = new SerializableOptionAppealTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionAppealTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

81
LooseDBTables/DB/patch_OptionBodybrightnessIDEnum.cs Normal file
View File

@ -0,0 +1,81 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionBodybrightnessIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionBodybrightnessTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionBodybrightnessTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String Detail;
public System.String FilePath;
public System.Boolean isDefault;
public System.Single Value;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionBodybrightnessIDEnum : OptionBodybrightnessIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionBodybrightnessTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionBodybrightnessTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, Detail = (System.String)src[i].Detail, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, Value = (System.Single)src[i].Value, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionBodybrightnessTableRecord>() {
records = new SerializableOptionBodybrightnessTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionBodybrightnessTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, Detail = (System.String)src[i].Detail, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, Value = (System.Single)src[i].Value, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

84
LooseDBTables/DB/patch_OptionBreakseIDEnum.cs Normal file
View File

@ -0,0 +1,84 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionBreakseIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionBreakseTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionBreakseTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String SeGoodEnum;
public System.String SeBadEnum;
public System.Boolean isDefault;
public System.String FilePath;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionBreakseIDEnum : OptionBreakseIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionBreakseTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionBreakseTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, SeGoodEnum = (System.String)src[i].SeGoodEnum, SeBadEnum = (System.String)src[i].SeBadEnum, isDefault = (System.Boolean)src[i].isDefault, FilePath = (System.String)src[i].FilePath, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionBreakseTableRecord>() {
records = new SerializableOptionBreakseTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionBreakseTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, SeGoodEnum = (System.String)src[i].SeGoodEnum, SeBadEnum = (System.String)src[i].SeBadEnum, isDefault = (System.Boolean)src[i].isDefault, FilePath = (System.String)src[i].FilePath, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

80
LooseDBTables/DB/patch_OptionCateDesignIDEnum.cs Normal file
View File

@ -0,0 +1,80 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionCateDesignIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionCateDesignTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionCateDesignTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionCateDesignIDEnum : OptionCateDesignIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionCateDesignTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionCateDesignTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionCateDesignTableRecord>() {
records = new SerializableOptionCateDesignTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionCateDesignTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

80
LooseDBTables/DB/patch_OptionCateGameIDEnum.cs Normal file
View File

@ -0,0 +1,80 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionCateGameIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionCateGameTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionCateGameTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionCateGameIDEnum : OptionCateGameIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionCateGameTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionCateGameTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionCateGameTableRecord>() {
records = new SerializableOptionCateGameTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionCateGameTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

80
LooseDBTables/DB/patch_OptionCateJudgeIDEnum.cs Normal file
View File

@ -0,0 +1,80 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionCateJudgeIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionCateJudgeTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionCateJudgeTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionCateJudgeIDEnum : OptionCateJudgeIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionCateJudgeTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionCateJudgeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionCateJudgeTableRecord>() {
records = new SerializableOptionCateJudgeTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionCateJudgeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

80
LooseDBTables/DB/patch_OptionCateSoundIDEnum.cs Normal file
View File

@ -0,0 +1,80 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionCateSoundIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionCateSoundTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionCateSoundTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionCateSoundIDEnum : OptionCateSoundIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionCateSoundTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionCateSoundTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionCateSoundTableRecord>() {
records = new SerializableOptionCateSoundTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionCateSoundTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

80
LooseDBTables/DB/patch_OptionCateSpeedIDEnum.cs Normal file
View File

@ -0,0 +1,80 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionCateSpeedIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionCateSpeedTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionCateSpeedTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionCateSpeedIDEnum : OptionCateSpeedIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionCateSpeedTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionCateSpeedTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionCateSpeedTableRecord>() {
records = new SerializableOptionCateSpeedTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionCateSpeedTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

80
LooseDBTables/DB/patch_OptionCategoryIDEnum.cs Normal file
View File

@ -0,0 +1,80 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionCategoryIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionCategoryTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionCategoryTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.UInt32 MainColor;
public System.String Filename;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionCategoryIDEnum : OptionCategoryIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionCategoryTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionCategoryTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, MainColor = (System.UInt32)src[i].MainColor, Filename = (System.String)src[i].Filename, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionCategoryTableRecord>() {
records = new SerializableOptionCategoryTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionCategoryTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, MainColor = (System.UInt32)src[i].MainColor, Filename = (System.String)src[i].Filename, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_OptionCenterdisplayIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionCenterdisplayIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionCenterdisplayTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionCenterdisplayTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionCenterdisplayIDEnum : OptionCenterdisplayIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionCenterdisplayTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionCenterdisplayTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionCenterdisplayTableRecord>() {
records = new SerializableOptionCenterdisplayTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionCenterdisplayTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_OptionCriticalIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionCriticalIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionCriticalTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionCriticalTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.Boolean isDefault;
public System.String FilePath;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionCriticalIDEnum : OptionCriticalIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionCriticalTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionCriticalTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, isDefault = (System.Boolean)src[i].isDefault, FilePath = (System.String)src[i].FilePath, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionCriticalTableRecord>() {
records = new SerializableOptionCriticalTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionCriticalTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, isDefault = (System.Boolean)src[i].isDefault, FilePath = (System.String)src[i].FilePath, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_OptionDispbarlineIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionDispbarlineIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionDispbarlineTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionDispbarlineTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionDispbarlineIDEnum : OptionDispbarlineIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionDispbarlineTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionDispbarlineTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionDispbarlineTableRecord>() {
records = new SerializableOptionDispbarlineTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionDispbarlineTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_OptionDispchainIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionDispchainIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionDispchainTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionDispchainTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionDispchainIDEnum : OptionDispchainIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionDispchainTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionDispchainTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionDispchainTableRecord>() {
records = new SerializableOptionDispchainTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionDispchainTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

84
LooseDBTables/DB/patch_OptionDispjudgeIDEnum.cs Normal file
View File

@ -0,0 +1,84 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionDispjudgeIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionDispjudgeTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionDispjudgeTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
public System.Boolean isCritical;
public System.Boolean isFastlate;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionDispjudgeIDEnum : OptionDispjudgeIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionDispjudgeTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionDispjudgeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, isCritical = (System.Boolean)src[i].isCritical, isFastlate = (System.Boolean)src[i].isFastlate, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionDispjudgeTableRecord>() {
records = new SerializableOptionDispjudgeTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionDispjudgeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, isCritical = (System.Boolean)src[i].isCritical, isFastlate = (System.Boolean)src[i].isFastlate, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_OptionDispjudgeposIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionDispjudgeposIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionDispjudgeposTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionDispjudgeposTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionDispjudgeposIDEnum : OptionDispjudgeposIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionDispjudgeposTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionDispjudgeposTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionDispjudgeposTableRecord>() {
records = new SerializableOptionDispjudgeposTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionDispjudgeposTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_OptionDispjudgetouchposIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionDispjudgetouchposIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionDispjudgetouchposTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionDispjudgetouchposTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionDispjudgetouchposIDEnum : OptionDispjudgetouchposIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionDispjudgetouchposTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionDispjudgetouchposTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionDispjudgetouchposTableRecord>() {
records = new SerializableOptionDispjudgetouchposTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionDispjudgetouchposTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_OptionDisprateIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionDisprateIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionDisprateTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionDisprateTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionDisprateIDEnum : OptionDisprateIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionDisprateTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionDisprateTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionDisprateTableRecord>() {
records = new SerializableOptionDisprateTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionDisprateTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

83
LooseDBTables/DB/patch_OptionExseIDEnum.cs Normal file
View File

@ -0,0 +1,83 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionExseIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionExseTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionExseTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String SeEnum;
public System.Boolean isDefault;
public System.String FilePath;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionExseIDEnum : OptionExseIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionExseTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionExseTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, SeEnum = (System.String)src[i].SeEnum, isDefault = (System.Boolean)src[i].isDefault, FilePath = (System.String)src[i].FilePath, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionExseTableRecord>() {
records = new SerializableOptionExseTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionExseTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, SeEnum = (System.String)src[i].SeEnum, isDefault = (System.Boolean)src[i].isDefault, FilePath = (System.String)src[i].FilePath, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_OptionGameholdIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionGameholdIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionGameholdTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionGameholdTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.Boolean isDefault;
public System.String FilePath;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionGameholdIDEnum : OptionGameholdIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionGameholdTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionGameholdTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, isDefault = (System.Boolean)src[i].isDefault, FilePath = (System.String)src[i].FilePath, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionGameholdTableRecord>() {
records = new SerializableOptionGameholdTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionGameholdTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, isDefault = (System.Boolean)src[i].isDefault, FilePath = (System.String)src[i].FilePath, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_OptionGameoutlineIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionGameoutlineIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionGameoutlineTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionGameoutlineTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionGameoutlineIDEnum : OptionGameoutlineIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionGameoutlineTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionGameoutlineTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionGameoutlineTableRecord>() {
records = new SerializableOptionGameoutlineTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionGameoutlineTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_OptionGameslideIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionGameslideIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionGameslideTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionGameslideTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.Boolean isDefault;
public System.String FilePath;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionGameslideIDEnum : OptionGameslideIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionGameslideTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionGameslideTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, isDefault = (System.Boolean)src[i].isDefault, FilePath = (System.String)src[i].FilePath, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionGameslideTableRecord>() {
records = new SerializableOptionGameslideTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionGameslideTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, isDefault = (System.Boolean)src[i].isDefault, FilePath = (System.String)src[i].FilePath, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_OptionGametapIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionGametapIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionGametapTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionGametapTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.Boolean isDefault;
public System.String FilePath;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionGametapIDEnum : OptionGametapIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionGametapTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionGametapTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, isDefault = (System.Boolean)src[i].isDefault, FilePath = (System.String)src[i].FilePath, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionGametapTableRecord>() {
records = new SerializableOptionGametapTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionGametapTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, isDefault = (System.Boolean)src[i].isDefault, FilePath = (System.String)src[i].FilePath, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_OptionHeadphonevolumeIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionHeadphonevolumeIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionHeadphonevolumeTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionHeadphonevolumeTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.Single Value;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.Boolean isDefault;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionHeadphonevolumeIDEnum : OptionHeadphonevolumeIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionHeadphonevolumeTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionHeadphonevolumeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Value = (System.Single)src[i].Value, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, isDefault = (System.Boolean)src[i].isDefault, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionHeadphonevolumeTableRecord>() {
records = new SerializableOptionHeadphonevolumeTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionHeadphonevolumeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Value = (System.Single)src[i].Value, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, isDefault = (System.Boolean)src[i].isDefault, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_OptionJudgetimingIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionJudgetimingIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionJudgetimingTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionJudgetimingTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionJudgetimingIDEnum : OptionJudgetimingIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionJudgetimingTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionJudgetimingTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionJudgetimingTableRecord>() {
records = new SerializableOptionJudgetimingTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionJudgetimingTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

80
LooseDBTables/DB/patch_OptionKindIDEnum.cs Normal file
View File

@ -0,0 +1,80 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionKindIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionKindTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionKindTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionKindIDEnum : OptionKindIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionKindTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionKindTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionKindTableRecord>() {
records = new SerializableOptionKindTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionKindTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

81
LooseDBTables/DB/patch_OptionMatchingIDEnum.cs Normal file
View File

@ -0,0 +1,81 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionMatchingIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionMatchingTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionMatchingTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionMatchingIDEnum : OptionMatchingIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionMatchingTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionMatchingTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionMatchingTableRecord>() {
records = new SerializableOptionMatchingTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionMatchingTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_OptionMirrorIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionMirrorIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionMirrorTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionMirrorTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionMirrorIDEnum : OptionMirrorIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionMirrorTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionMirrorTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionMirrorTableRecord>() {
records = new SerializableOptionMirrorTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionMirrorTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

83
LooseDBTables/DB/patch_OptionMoviebrightnessIDEnum.cs Normal file
View File

@ -0,0 +1,83 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionMoviebrightnessIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionMoviebrightnessTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionMoviebrightnessTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.Single Value;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionMoviebrightnessIDEnum : OptionMoviebrightnessIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionMoviebrightnessTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionMoviebrightnessTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Value = (System.Single)src[i].Value, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionMoviebrightnessTableRecord>() {
records = new SerializableOptionMoviebrightnessTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionMoviebrightnessTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Value = (System.Single)src[i].Value, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

83
LooseDBTables/DB/patch_OptionNotesizeIDEnum.cs Normal file
View File

@ -0,0 +1,83 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionNotesizeIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionNotesizeTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionNotesizeTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
public System.Single Value;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionNotesizeIDEnum : OptionNotesizeIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionNotesizeTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionNotesizeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, Value = (System.Single)src[i].Value, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionNotesizeTableRecord>() {
records = new SerializableOptionNotesizeTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionNotesizeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, Value = (System.Single)src[i].Value, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

83
LooseDBTables/DB/patch_OptionNotespeedIDEnum.cs Normal file
View File

@ -0,0 +1,83 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionNotespeedIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionNotespeedTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionNotespeedTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.Single Value;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionNotespeedIDEnum : OptionNotespeedIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionNotespeedTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionNotespeedTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Value = (System.Single)src[i].Value, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionNotespeedTableRecord>() {
records = new SerializableOptionNotespeedTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionNotespeedTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Value = (System.Single)src[i].Value, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_OptionOutframedisplayIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionOutframedisplayIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionOutframedisplayTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionOutframedisplayTableRecord {
public System.String EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionOutframedisplayIDEnum : OptionOutframedisplayIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionOutframedisplayTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionOutframedisplayTableRecord { EnumValue = (System.String)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionOutframedisplayTableRecord>() {
records = new SerializableOptionOutframedisplayTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionOutframedisplayTableRecord { EnumValue = (System.String)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

77
LooseDBTables/DB/patch_OptionRootIDEnum.cs Normal file
View File

@ -0,0 +1,77 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionRootIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionRootTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionRootTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionRootIDEnum : OptionRootIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionRootTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionRootTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionRootTableRecord>() {
records = new SerializableOptionRootTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionRootTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

83
LooseDBTables/DB/patch_OptionSlideseIDEnum.cs Normal file
View File

@ -0,0 +1,83 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionSlideseIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionSlideseTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionSlideseTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String SeEnum;
public System.Boolean isDefault;
public System.String FilePath;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionSlideseIDEnum : OptionSlideseIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionSlideseTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionSlideseTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, SeEnum = (System.String)src[i].SeEnum, isDefault = (System.Boolean)src[i].isDefault, FilePath = (System.String)src[i].FilePath, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionSlideseTableRecord>() {
records = new SerializableOptionSlideseTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionSlideseTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, SeEnum = (System.String)src[i].SeEnum, isDefault = (System.Boolean)src[i].isDefault, FilePath = (System.String)src[i].FilePath, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

83
LooseDBTables/DB/patch_OptionSlidesizeIDEnum.cs Normal file
View File

@ -0,0 +1,83 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionSlidesizeIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionSlidesizeTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionSlidesizeTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
public System.Single Value;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionSlidesizeIDEnum : OptionSlidesizeIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionSlidesizeTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionSlidesizeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, Value = (System.Single)src[i].Value, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionSlidesizeTableRecord>() {
records = new SerializableOptionSlidesizeTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionSlidesizeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, Value = (System.Single)src[i].Value, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_OptionSlidespeedIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionSlidespeedIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionSlidespeedTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionSlidespeedTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionSlidespeedIDEnum : OptionSlidespeedIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionSlidespeedTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionSlidespeedTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionSlidespeedTableRecord>() {
records = new SerializableOptionSlidespeedTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionSlidespeedTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_OptionStarrotateIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionStarrotateIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionStarrotateTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionStarrotateTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionStarrotateIDEnum : OptionStarrotateIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionStarrotateTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionStarrotateTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionStarrotateTableRecord>() {
records = new SerializableOptionStarrotateTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionStarrotateTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_OptionStartypeIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionStartypeIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionStartypeTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionStartypeTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionStartypeIDEnum : OptionStartypeIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionStartypeTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionStartypeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionStartypeTableRecord>() {
records = new SerializableOptionStartypeTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionStartypeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_OptionSubmonAchiveIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionSubmonAchiveIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionSubmonAchiveTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionSubmonAchiveTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionSubmonAchiveIDEnum : OptionSubmonAchiveIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionSubmonAchiveTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionSubmonAchiveTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionSubmonAchiveTableRecord>() {
records = new SerializableOptionSubmonAchiveTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionSubmonAchiveTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_OptionSubmonitorIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionSubmonitorIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionSubmonitorTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionSubmonitorTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.Boolean isDefault;
public System.String FilePath;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionSubmonitorIDEnum : OptionSubmonitorIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionSubmonitorTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionSubmonitorTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, isDefault = (System.Boolean)src[i].isDefault, FilePath = (System.String)src[i].FilePath, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionSubmonitorTableRecord>() {
records = new SerializableOptionSubmonitorTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionSubmonitorTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, isDefault = (System.Boolean)src[i].isDefault, FilePath = (System.String)src[i].FilePath, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

86
LooseDBTables/DB/patch_OptionTapSuccessSeIDEnum.cs Normal file
View File

@ -0,0 +1,86 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionTapSuccessSeIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionTapSuccessSeTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionTapSuccessSeTableRecord {
public System.String EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String SeEnumCritical;
public System.String SeEnumPerfect;
public System.String SeEnumGreat;
public System.String SeEnumGood;
public System.Boolean isDefault;
public System.String FilePath;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionTapSuccessSeIDEnum : OptionTapSuccessSeIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionTapSuccessSeTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionTapSuccessSeTableRecord { EnumValue = (System.String)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, SeEnumCritical = (System.String)src[i].SeEnumCritical, SeEnumPerfect = (System.String)src[i].SeEnumPerfect, SeEnumGreat = (System.String)src[i].SeEnumGreat, SeEnumGood = (System.String)src[i].SeEnumGood, isDefault = (System.Boolean)src[i].isDefault, FilePath = (System.String)src[i].FilePath, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionTapSuccessSeTableRecord>() {
records = new SerializableOptionTapSuccessSeTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionTapSuccessSeTableRecord { EnumValue = (System.String)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, SeEnumCritical = (System.String)src[i].SeEnumCritical, SeEnumPerfect = (System.String)src[i].SeEnumPerfect, SeEnumGreat = (System.String)src[i].SeEnumGreat, SeEnumGood = (System.String)src[i].SeEnumGood, isDefault = (System.Boolean)src[i].isDefault, FilePath = (System.String)src[i].FilePath, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_OptionToucheffectIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionToucheffectIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionToucheffectTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionToucheffectTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionToucheffectIDEnum : OptionToucheffectIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionToucheffectTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionToucheffectTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionToucheffectTableRecord>() {
records = new SerializableOptionToucheffectTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionToucheffectTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

83
LooseDBTables/DB/patch_OptionTouchsizeIDEnum.cs Normal file
View File

@ -0,0 +1,83 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionTouchsizeIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionTouchsizeTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionTouchsizeTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
public System.Single Value;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionTouchsizeIDEnum : OptionTouchsizeIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionTouchsizeTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionTouchsizeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, Value = (System.Single)src[i].Value, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionTouchsizeTableRecord>() {
records = new SerializableOptionTouchsizeTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionTouchsizeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, Value = (System.Single)src[i].Value, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

83
LooseDBTables/DB/patch_OptionTouchspeedIDEnum.cs Normal file
View File

@ -0,0 +1,83 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionTouchspeedIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionTouchspeedTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionTouchspeedTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.Single Value;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionTouchspeedIDEnum : OptionTouchspeedIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionTouchspeedTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionTouchspeedTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Value = (System.Single)src[i].Value, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionTouchspeedTableRecord>() {
records = new SerializableOptionTouchspeedTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionTouchspeedTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Value = (System.Single)src[i].Value, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

82
LooseDBTables/DB/patch_OptionTrackskipIDEnum.cs Normal file
View File

@ -0,0 +1,82 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionTrackskipIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionTrackskipTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionTrackskipTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionTrackskipIDEnum : OptionTrackskipIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionTrackskipTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionTrackskipTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionTrackskipTableRecord>() {
records = new SerializableOptionTrackskipTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionTrackskipTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

83
LooseDBTables/DB/patch_OptionVolumeAnswerSoundIDEnum.cs Normal file
View File

@ -0,0 +1,83 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionVolumeAnswerSoundIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionVolumeAnswerSoundTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionVolumeAnswerSoundTableRecord {
public System.String EnumValue;
public System.String EnumName;
public System.Single Value;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionVolumeAnswerSoundIDEnum : OptionVolumeAnswerSoundIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionVolumeAnswerSoundTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionVolumeAnswerSoundTableRecord { EnumValue = (System.String)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Value = (System.Single)src[i].Value, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionVolumeAnswerSoundTableRecord>() {
records = new SerializableOptionVolumeAnswerSoundTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionVolumeAnswerSoundTableRecord { EnumValue = (System.String)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Value = (System.Single)src[i].Value, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

83
LooseDBTables/DB/patch_OptionVolumeIDEnum.cs Normal file
View File

@ -0,0 +1,83 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class OptionVolumeIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static OptionVolumeTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializableOptionVolumeTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.Single Value;
public System.String Name;
public System.String NameEx;
public System.String Detail;
public System.String DetailEx;
public System.String FilePath;
public System.Boolean isDefault;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_OptionVolumeIDEnum : OptionVolumeIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializableOptionVolumeTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new OptionVolumeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Value = (System.Single)src[i].Value, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializableOptionVolumeTableRecord>() {
records = new SerializableOptionVolumeTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializableOptionVolumeTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Value = (System.Single)src[i].Value, Name = (System.String)src[i].Name, NameEx = (System.String)src[i].NameEx, Detail = (System.String)src[i].Detail, DetailEx = (System.String)src[i].DetailEx, FilePath = (System.String)src[i].FilePath, isDefault = (System.Boolean)src[i].isDefault, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

79
LooseDBTables/DB/patch_PartyAdvertiseStateIDEnum.cs Normal file
View File

@ -0,0 +1,79 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class PartyAdvertiseStateIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static PartyAdvertiseStateTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializablePartyAdvertiseStateTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
public System.Boolean isNormal;
public System.Boolean isGo;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_PartyAdvertiseStateIDEnum : PartyAdvertiseStateIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializablePartyAdvertiseStateTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new PartyAdvertiseStateTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, isNormal = (System.Boolean)src[i].isNormal, isGo = (System.Boolean)src[i].isGo, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializablePartyAdvertiseStateTableRecord>() {
records = new SerializablePartyAdvertiseStateTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializablePartyAdvertiseStateTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, isNormal = (System.Boolean)src[i].isNormal, isGo = (System.Boolean)src[i].isGo, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

77
LooseDBTables/DB/patch_PartyConnectStateIDEnum.cs Normal file
View File

@ -0,0 +1,77 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class PartyConnectStateIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static PartyConnectStateTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializablePartyConnectStateTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_PartyConnectStateIDEnum : PartyConnectStateIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializablePartyConnectStateTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new PartyConnectStateTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializablePartyConnectStateTableRecord>() {
records = new SerializablePartyConnectStateTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializablePartyConnectStateTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

77
LooseDBTables/DB/patch_PartyDeliveryCheckerErrorIDEnum.cs Normal file
View File

@ -0,0 +1,77 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class PartyDeliveryCheckerErrorIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static PartyDeliveryCheckerErrorTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializablePartyDeliveryCheckerErrorTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_PartyDeliveryCheckerErrorIDEnum : PartyDeliveryCheckerErrorIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializablePartyDeliveryCheckerErrorTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new PartyDeliveryCheckerErrorTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializablePartyDeliveryCheckerErrorTableRecord>() {
records = new SerializablePartyDeliveryCheckerErrorTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializablePartyDeliveryCheckerErrorTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

77
LooseDBTables/DB/patch_PartyDeliveryCheckerStateIDEnum.cs Normal file
View File

@ -0,0 +1,77 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class PartyDeliveryCheckerStateIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static PartyDeliveryCheckerStateTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializablePartyDeliveryCheckerStateTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_PartyDeliveryCheckerStateIDEnum : PartyDeliveryCheckerStateIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializablePartyDeliveryCheckerStateTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new PartyDeliveryCheckerStateTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializablePartyDeliveryCheckerStateTableRecord>() {
records = new SerializablePartyDeliveryCheckerStateTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializablePartyDeliveryCheckerStateTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

77
LooseDBTables/DB/patch_PartyHeartBeatStateIDEnum.cs Normal file
View File

@ -0,0 +1,77 @@
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;
using MonoMod;
using LooseDBTables;
using UnityEngine;
namespace DB;
[MonoModIgnore]
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class PartyHeartBeatStateIDEnum
{
public static extern bool LoadFromFile(string filename);
public static extern void DumpToFile(string filename);
protected static PartyHeartBeatStateTableRecord[] records;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
[Serializable]
public class SerializablePartyHeartBeatStateTableRecord {
public System.Int32 EnumValue;
public System.String EnumName;
public System.String Name;
}
[GeneratedCode("LooseDBTables.GeneratePatches", "1.0.0.0")]
public class patch_PartyHeartBeatStateIDEnum : PartyHeartBeatStateIDEnum {
public new static bool LoadFromFile(string filename) {
if (!File.Exists(filename)) {
return false;
}
var table = JsonUtility.FromJson<Table<SerializablePartyHeartBeatStateTableRecord>>(File.ReadAllText(filename));
try
{
if (table.records.Length != records.Length) {
Debug.LogError($"Count read error: {filename}");
return false;
}
var src = table.records;
var dst = records;
for (var i = 0; i < table.records.Length; i++) {
dst[i] = new PartyHeartBeatStateTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
}
catch
{
Debug.LogError($"File read error: {filename}");
return false;
}
return true;
}
public new static void DumpToFile(string filename) {
var table = new Table<SerializablePartyHeartBeatStateTableRecord>() {
records = new SerializablePartyHeartBeatStateTableRecord[records.Length]
};
var src = records;
var dst = table.records;
for (var i = 0; i < records.Length; i++) {
dst[i] = new SerializablePartyHeartBeatStateTableRecord { EnumValue = (System.Int32)src[i].EnumValue, EnumName = (System.String)src[i].EnumName, Name = (System.String)src[i].Name, };
}
File.WriteAllText(filename, JsonUtility.ToJson(table, true), Encoding.UTF8);
}
}

Some files were not shown because too many files have changed in this diff Show More