private void UpdateDifficultyNGram()
{
Vector3 playerPosition = blackBoard.LevelInfo.Player.transform.position;
int toRight = blackBoard.ConfigUI.Config.DifficultyNGramRightColumns;
int toLeft = blackBoard.ConfigUI.Config.DifficultyNGramLeftColumns;
Tilemap tilemap = blackBoard.Tilemap;
Vector3Int tilePosition = tilemap.WorldToCell(playerPosition);
int x = Math.Max(tilePosition.x - toLeft, tilemap.cellBounds.xMin);
int xMax = Math.Min(tilePosition.x + toRight, tilemap.cellBounds.xMax - 1);
blackBoard.DifficultyNGram.UpdateMemory(blackBoard.ConfigUI.Config.DifficultyNGramMemoryUpdate);
List <string> difficultPart = blackBoard.LevelColumns.GetRange(x, xMax - x + 1);
NGramTrainer.Train(blackBoard.DifficultyNGram, difficultPart);
if (blackBoard.ConfigUI.Config.UsingSimplifiedNGram)
{
blackBoard.SimpleDifficultyNGram.UpdateMemory(blackBoard.ConfigUI.Config.DifficultyNGramMemoryUpdate);
NGramTrainer.Train(
blackBoard.SimpleDifficultyNGram,
LevelParser.BreakColumnsIntoSimplifiedTokens(
difficultPart,
blackBoard.ConfigUI.Config.Game));
}
}
private void GenerateNGram()
{
if (blackBoard.ConfigUI.Config.HeiarchalEnabled)
{
grammar = NGramFactory.InitHierarchicalNGram(
blackBoard.ConfigUI.Config.N,
blackBoard.ConfigUI.Config.HeiarchalMemory);
simpleGrammar = NGramFactory.InitHierarchicalNGram(
blackBoard.ConfigUI.Config.N,
blackBoard.ConfigUI.Config.HeiarchalMemory);
}
else if (blackBoard.ConfigUI.Config.BackOffEnabled)
{
grammar = NGramFactory.InitHierarchicalNGram(
blackBoard.ConfigUI.Config.N,
blackBoard.ConfigUI.Config.BackOffMemory);
simpleGrammar = NGramFactory.InitHierarchicalNGram(
blackBoard.ConfigUI.Config.N,
blackBoard.ConfigUI.Config.BackOffMemory);
}
else
{
grammar = NGramFactory.InitGrammar(blackBoard.ConfigUI.Config.N);
simpleGrammar = NGramFactory.InitGrammar(blackBoard.ConfigUI.Config.N);
}
for (int i = 0; i <= blackBoard.ProgressIndex; ++i)
{
if (blackBoard.ConfigUI.Config.UsingTieredGeneration || blackBoard.ProgressIndex == i)
{
JsonObject tierInfo = blackBoard.GameFlow[i].AsJsonObject;
JsonArray tierLevels = tierInfo[FlowKeys.LevelNames].AsJsonArray;
foreach (string levelName in tierLevels)
{
List <string> columns = LevelParser.BreakMapIntoColumns(levelName);
columns.RemoveAt(columns.Count - 1); // remove flag at the end
List <string> simpleColumns = LevelParser.BreakColumnsIntoSimplifiedTokens(
columns,
blackBoard.ConfigUI.Config.Game);
levelColumns.Add(columns);
simplifiedLevelColumns.Add(simpleColumns);
NGramTrainer.Train(grammar, columns, skipFirst: true);
NGramTrainer.Train(simpleGrammar, simpleColumns, skipFirst: true);
if (blackBoard.ProgressIndex != i)
{
grammar.UpdateMemory(blackBoard.ConfigUI.Config.TieredGenerationMemoryUpdate);
levelColumns.Clear();
simplifiedLevelColumns.Clear();
}
}
}
}
}
public void AddData(string[] inData, string outData)
{
Assert.IsTrue(inData.Length == N - 1);
List <string> data = new List <string>();
data.AddRange(inData);
data.Add(outData);
foreach (IGram gram in Grammars)
{
NGramTrainer.Train(gram, data);
}
}
private List <SimulationThread> GetSimulationThreads(string levelFlowPath, string name, Games game)
{
// We first get all the levels from the flow and then get the start
// input from the first level in the sequence. Note that the first
// we use the same start input but we don't want that to scew
// results. To get around this, we use a flag in the ngram generator
// which will not include the start output in the end result.
List <List <string> > levels = BuildSimulator.GetLevels(levelFlowPath);
List <string> startInput = levels[0].GetRange(0, 10);
List <SimulationThread> threads = new List <SimulationThread>();
for (int i = 1; i <= 6; ++i)
{
IGram gram = NGramFactory.InitGrammar(i);
foreach (List <string> level in levels)
{
NGramTrainer.Train(gram, level, skipFirst: true);
}
//threads.Add(BuildThread(gram, null, startInput, game, $"{name}_{Size}_ngram"));
if (i != 1)
{
gram = NGramFactory.InitHierarchicalNGram(i, 0.6f);
IGram simpleGram = NGramFactory.InitHierarchicalNGram(i, 0.6f);
IGram bgram = NGramFactory.InitBackOffNGram(i, 0.6f);
foreach (List <string> level in levels)
{
NGramTrainer.Train(gram, level, skipFirst: true);
NGramTrainer.Train(bgram, level, skipFirst: true);
NGramTrainer.Train(
simpleGram,
LevelParser.BreakColumnsIntoSimplifiedTokens(
level,
game),
skipFirst: true);
}
//threads.Add(BuildThread(gram, null, startInput, game, $"{name}_{Size}_heirarchical"));
threads.Add(BuildThread(gram, simpleGram, startInput, game, $"{name}_{Size}_simple_heirarchical"));
//threads.Add(BuildThread(bgram, null, startInput, game, $"{name}_{Size}_backoff"));
// threads.Add(BuildThread(bgram, simpleGram, startInput, game, $"{name}_{Size}_simple_backoff"));
}
}
return(threads);
}
