private async Task LoadNewSaveFile(SaveFile sav)
{
if (sav == null)
{
await UserDialogs.Instance.AlertAsync("No Save File selected.").ConfigureAwait(false);
return;
}
if (!sav.ChecksumsValid)
{
const string proceed = "Continue";
var result = await UserDialogs.Instance.ActionSheetAsync("Bad checksums detected.", "Abort", null, null, proceed).ConfigureAwait(false);
if (result != proceed)
{
return;
}
}
Device.BeginInvokeOnMainThread(() =>
{
var l = new LoadableSAV(sav.Metadata.FilePath, sav);
TrainerSettings.Register(sav);
VM.Saves.Add(l);
CV_Saves.SelectedItem = l;
B_Open.IsVisible = true;
});
}
public static async Task ReplyWithLegalizedSetAsync(this ISocketMessageChannel channel, string content)
{
content = ReusableActions.StripCodeBlock(content);
var set = new ShowdownSet(content);
var sav = TrainerSettings.GetSavedTrainerData(set.Format);
await channel.ReplyWithLegalizedSetAsync(sav, set).ConfigureAwait(false);
}
protected BaseTrainer(IEnumerable <Example> trainingExamples, TrainerSettings settings)
{
var examples = trainingExamples.ToList();
ExamplesCount = examples.Count;
Init(examples, settings);
}
static AutoLegalityExtensions()
{
Task.Run(() => {
var lang = Thread.CurrentThread.CurrentCulture.TwoLetterISOLanguageName.Substring(0, 2);
Util.SetLocalization(typeof(LegalityCheckStrings), lang);
Util.SetLocalization(typeof(MessageStrings), lang);
RibbonStrings.ResetDictionary(GameInfo.Strings.ribbons);
});
// Seed the Trainer Database with enough fake save files so that we return a generation sensitive format when needed.
for (int i = 1; i < PKX.Generation; i++)
{
const string OT = "PKHeX-D";
var blankSAV = SaveUtil.GetBlankSAV(i, OT);
TrainerSettings.Register(blankSAV);
}
var trainer = TrainerSettings.GetSavedTrainerData(7);
PKMConverter.SetPrimaryTrainer(trainer);
// Legalizer.AllowBruteForce = false;
// Update Legality Analysis strings
LegalityAnalysis.MoveStrings = GameInfo.Strings.movelist;
LegalityAnalysis.SpeciesStrings = GameInfo.Strings.specieslist;
}
private void Init(IEnumerable <Example> trainingExamples, TrainerSettings settings)
{
TrainingExamples = trainingExamples;
Optimizer = settings.Optimizer;
EpochsCount = settings.EpochsCount;
LossFunction = settings.LossFunction;
Metric = settings.Metric;
}
public ITrainerInfo GetTrainerInfo <T>() where T : PKM, new()
{
if (typeof(T) == typeof(PK8))
{
return(TrainerSettings.GetSavedTrainerData(GameVersion.SWSH, 8));
}
if (typeof(T) == typeof(PB8))
{
return(TrainerSettings.GetSavedTrainerData(GameVersion.BDSP, 8));
}
throw new ArgumentException("Type does not have a recognized trainer fetch.", typeof(T).Name);
}
private static void InitializeTrainerDatabase()
{
var ot = GetEnvOrThrow("PKHEX_DEFAULT_OT");
var trainerId = int.Parse(GetEnvOrThrow("PKHEX_DEFAULT_TID"));
var secretId = int.Parse(GetEnvOrThrow("PKHEX_DEFAULT_SID"));
var languageName = GetEnvOrThrow("PKHEX_DEFAULT_LANGUAGE");
if (!Enum.TryParse <LanguageID>(languageName, true, out var language))
{
throw new Exception($"Invalid default language {languageName}");
}
SaveFile GetFallbackBlank(int generation)
{
var blankSav = SaveUtil.GetBlankSAV(generation, ot);
blankSav.Language = (int)language;
blankSav.TID = trainerId;
blankSav.SID = secretId;
blankSav.OT = ot;
return(blankSav);
}
for (var i = 1; i < PKX.Generation + 1; i++)
{
var versions = GameUtil.GetVersionsInGeneration(i, PKX.Generation);
foreach (var v in versions)
{
var fallback = new SimpleTrainerInfo(v)
{
Language = (int)language,
TID = trainerId,
SID = secretId,
OT = ot,
};
var exist = TrainerSettings.GetSavedTrainerData(v, i, fallback);
if (exist is SimpleTrainerInfo)
{
TrainerSettings.Register(fallback);
}
}
}
var trainer = TrainerSettings.GetSavedTrainerData(PKX.Generation);
PKMConverter.SetPrimaryTrainer(trainer);
}
private static void InitializeTrainerDatabase()
{
// Seed the Trainer Database with enough fake save files so that we return a generation sensitive format when needed.
var cfg = SysCordInstance.Self.Hub.Config;
string OT = cfg.GenerateOT;
int TID = cfg.GenerateTID16;
int SID = cfg.GenerateSID16;
int lang = (int)cfg.GenerateLanguage;
var externalSource = cfg.GeneratePathTrainerInfo;
if (!string.IsNullOrWhiteSpace(externalSource) && Directory.Exists(externalSource))
{
TrainerSettings.LoadTrainerDatabaseFromPath(externalSource);
}
SaveFile GetFallbackBlank(int generation)
{
var blankSav = SaveUtil.GetBlankSAV(generation, OT);
blankSav.Language = lang;
blankSav.TID = TID;
blankSav.SID = SID;
blankSav.OT = OT;
return(blankSav);
}
for (int i = 1; i < PKX.Generation; i++)
{
var fallback = GetFallbackBlank(i);
var exist = TrainerSettings.GetSavedTrainerData(i, fallback);
if (exist == fallback)
{
TrainerSettings.Register(fallback);
}
}
var trainer = TrainerSettings.GetSavedTrainerData(7);
PKMConverter.SetPrimaryTrainer(trainer);
}
private static void InitializeTrainerDatabase(LegalitySettings cfg)
{
// Seed the Trainer Database with enough fake save files so that we return a generation sensitive format when needed.
string OT = cfg.GenerateOT;
int TID = cfg.GenerateTID16;
int SID = cfg.GenerateSID16;
int lang = (int)cfg.GenerateLanguage;
var externalSource = cfg.GeneratePathTrainerInfo;
if (!string.IsNullOrWhiteSpace(externalSource) && Directory.Exists(externalSource))
{
TrainerSettings.LoadTrainerDatabaseFromPath(externalSource);
}
for (int i = 1; i < PKX.Generation + 1; i++)
{
var versions = GameUtil.GetVersionsInGeneration(i, PKX.Generation);
foreach (var v in versions)
{
var fallback = new SimpleTrainerInfo(v)
{
Language = lang,
TID = TID,
SID = SID,
OT = OT,
};
var exist = TrainerSettings.GetSavedTrainerData(v, i, fallback);
if (exist is SimpleTrainerInfo) // not anything from files; this assumes ALM returns SimpleTrainerInfo for non-user-provided fake templates.
{
TrainerSettings.Register(fallback);
}
}
}
var trainer = TrainerSettings.GetSavedTrainerData(PKX.Generation);
PKMConverter.SetPrimaryTrainer(trainer);
}
private void WriteBehaviorsToClass(TrainerSettings settings)
{
for (int i = 0; i < settings.trainer_settings.Count; i++)
{
UpdateBehaviorsClass(settings, settings.trainer_settings[i]);
}
for (int i = 0; i < settings.hyperparameters.hyperparameters_entries_base.Count; i++)
{
UpdateBehaviorsClass(settings, settings.hyperparameters.hyperparameters_entries_base[i]);
}
for (int i = 0; i < settings.hyperparameters.hyperparameters_entries_ppo.Count; i++)
{
UpdateBehaviorsClass(settings, settings.hyperparameters.hyperparameters_entries_ppo[i]);
}
for (int i = 0; i < settings.hyperparameters.hyperparameters_entries_sac.Count; i++)
{
UpdateBehaviorsClass(settings, settings.hyperparameters.hyperparameters_entries_sac[i]);
}
for (int i = 0; i < settings.network_settings.network_settings_entries.Count; i++)
{
UpdateBehaviorsClass(settings, settings.network_settings.network_settings_entries[i]);
}
}
public static ITrainerInfo GetTrainerInfo(int gen) => TrainerSettings.GetSavedTrainerData(gen);
protected BaseTrainer(IExamplesSource examplesSource, TrainerSettings settings)
{
ExamplesCount = examplesSource.ExamplesCount;
Init(examplesSource.GetExamples(), settings);
}
public void ReadFile()
{
defaultSettings = new TrainerSettings("default_settings", alwaysActive: true, inUse: false);
multipleBehaviours = new MultipleBehaviours("behaviors", alwaysActive: false);
engineSettings = new EngineSettings(inUse: false);
checkpointSettings = new CheckpointSettings(inUse: false);
torchSettings = new TorchSettings(inUse: false);
using (StreamReader sr = new StreamReader(Path))
{
string line = "";
string settingsType = "";
string multipleBehavioursType = "";
while ((line = sr.ReadLine()) != null)
{
var spiltFile = line.Split(':');
string key = Regex.Replace(spiltFile[0], @"\s+", "");
string value = Regex.Replace(spiltFile[1], @"\s+", "");
switch (key)
{
case "default_settings":
defaultSettings.inUse = true;
settingsType = "default_settings";
break;
case "behaviors":
settingsType = "behaviors";
break;
case "engine_settings":
engineSettings.inUse = true;
settingsType = "engine_settings";
break;
case "checkpoint_settings":
checkpointSettings.inUse = true;
settingsType = "checkpoint_settings";
break;
case "torch_settings":
torchSettings.inUse = true;
settingsType = "torch_settings";
break;
default:
break;
}
switch (settingsType)
{
case "behaviors":
if (value == "" && key == "behaviors")
{
readDataMultipleBehaviours[settingsType] = new Dictionary <string, Dictionary <string, string> >();
}
else if (value == "" && !(new List <string> {
"behaviors", "hyperparameters", "network_settings"
}.Contains(key)))
{
multipleBehavioursType = key;
readDataMultipleBehaviours[settingsType][multipleBehavioursType] = new Dictionary <string, string>();
}
else if (key != "behaviors")
{
readDataMultipleBehaviours[settingsType][multipleBehavioursType][key] = value;
}
break;
default:
if (!readData.ContainsKey(settingsType))
{
readData[settingsType] = new Dictionary <string, string>();
}
else
{
readData[settingsType][key] = value;
}
break;
}
}
}
if (defaultSettings.inUse)
{
WriteBehaviorsToClass(defaultSettings);
}
if (readDataMultipleBehaviours.ContainsKey("behaviors"))
{
int index = 0;
foreach (KeyValuePair <string, Dictionary <string, string> > behaviors in readDataMultipleBehaviours["behaviors"])
{
multipleBehaviours.behaviors.Add(new Config.TrainerSettingsMultipleBehaviour(behaviors.Key));
WriteBehaviorsToClass(multipleBehaviours.behaviors[index].Behaviour);
var settings = multipleBehaviours.behaviors[index];
for (int i = 0; i < settings.Behaviour.trainer_settings.Count; i++)
{
UpdateMultipleBehavioursClass(readDataMultipleBehaviours, settings, settings.Behaviour.trainer_settings[i]);
}
for (int i = 0; i < settings.Behaviour.hyperparameters.hyperparameters_entries_base.Count; i++)
{
UpdateMultipleBehavioursClass(readDataMultipleBehaviours, settings, settings.Behaviour.trainer_settings[i]);
}
for (int i = 0; i < settings.Behaviour.hyperparameters.hyperparameters_entries_ppo.Count; i++)
{
UpdateMultipleBehavioursClass(readDataMultipleBehaviours, settings, settings.Behaviour.trainer_settings[i]);
}
for (int i = 0; i < settings.Behaviour.hyperparameters.hyperparameters_entries_sac.Count; i++)
{
UpdateMultipleBehavioursClass(readDataMultipleBehaviours, settings, settings.Behaviour.trainer_settings[i]);
}
for (int i = 0; i < settings.Behaviour.network_settings.network_settings_entries.Count; i++)
{
UpdateMultipleBehavioursClass(readDataMultipleBehaviours, settings, settings.Behaviour.trainer_settings[i]);
}
index++;
}
}
WriteToClass(engineSettings, engineSettings.engine_settings);
WriteToClass(checkpointSettings, checkpointSettings.checkpoint_settings);
WriteToClass(torchSettings, torchSettings.device);
// logging
// foreach (KeyValuePair<string, Dictionary<string, string>> attachStat1 in readData)
// {
// Debug.Log(attachStat1.Key);
// foreach (KeyValuePair<string, string> attachStat2 in attachStat1.Value)
// {
// Debug.Log(attachStat2.Key);
// Debug.Log(attachStat2.Value);
// }
// }
// foreach (KeyValuePair<string, Dictionary<string, Dictionary<string, string>>> attachStat1 in readDataMultipleBehaviours)
// {
// Debug.Log(attachStat1.Key);
// foreach (KeyValuePair<string, Dictionary<string, string>> attachStat2 in attachStat1.Value)
// {
// Debug.Log(attachStat2.Key);
// foreach (KeyValuePair<string, string> attachStat3 in attachStat2.Value)
// {
// Debug.Log(attachStat3.Key);
// Debug.Log(attachStat3.Value);
// }
// }
// }
}
