public static void Main(string[] args)
{
var src = MatrixDeserializer.Deserialize(File.ReadAllBytes(@"..\..\..\data\problemsF\FR001_src.mdl"));
var tgt = MatrixDeserializer.Deserialize(File.ReadAllBytes(@"..\..\..\data\problemsF\FR001_tgt.mdl"));
var mongoOplogWriter = new JsonOpLogWriter(new MongoJsonWriter());
mongoOplogWriter.WriteLogName("ComponentFinder");
var state = State.CreateInitial(src.R, mongoOplogWriter);
mongoOplogWriter.WriteInitialState(state);
var rand = new Random();
foreach (var comp in new ComponentFinder(src ^ tgt, tgt).Find())
{
if (comp.Fill)
{
var color = new[] { "00FF00", "FF0000", "0000FF", "FFFF00" }[rand.Next(3)];
mongoOplogWriter.WriteGroupColor(comp.Points.ToArray(), color, 0.8);
}
}
mongoOplogWriter.Save();
}
public static void Main(string[] args)
{
var modelFilePath = @"\\vm-dev-cont1\c$\data\problemsF\FA019_tgt.mdl";
var mongoOplogWriter = new JsonOpLogWriter(new MongoJsonWriter());
var jenyaRomaSolver = new JenyaRomaSolver(mongoOplogWriter);
var tgtMatrix = MatrixDeserializer.Deserialize(File.ReadAllBytes(modelFilePath));
var trace = jenyaRomaSolver.Solve(srcMatrix: null, tgtMatrix: tgtMatrix);
var traceBytes = TraceBinarySerializer.Create().Serialize(trace);
File.WriteAllBytes(@"FA019.nbt", traceBytes);
}
public static void Test()
{
var modelFilePath = @"..\..\..\data\models\LA020_tgt.mdl";
var matrix = MatrixDeserializer.Deserialize(File.ReadAllBytes(modelFilePath));
var mongoOplogWriter = new JsonOpLogWriter(new MongoJsonWriter());
mongoOplogWriter.WriteLogName("GreedyGravityAI_IsGrounded");
var state = State.CreateInitial(matrix.R, mongoOplogWriter);
mongoOplogWriter.WriteInitialState(state);
var groundedChecker = new IsGroundedChecker(matrix);
var vertexex = new List <Vector>();
for (int y = 0; y < matrix.R; y++)
{
for (int x = 0; x < matrix.R; x++)
{
for (int z = 0; z < matrix.R; z++)
{
var vector = new Vector(x, y, z);
if (matrix.IsVoid(vector))
{
continue;
}
vertexex.Add(vector);
}
}
}
var rand = new Random();
vertexex = vertexex.OrderBy(_ => rand.NextDouble()).ToList();
foreach (var vector in vertexex)
{
if (groundedChecker.CanRemove(vector))
{
groundedChecker.UpdateWithClear(vector);
continue;
}
mongoOplogWriter.WriteFill(vector);
}
mongoOplogWriter.Save();
}
public static void Visualize(Matrix matrix, string name)
{
var oplogWriter = new JsonOpLogWriter(new MongoJsonWriter("models"));
oplogWriter.WriteLogName(name);
oplogWriter.WriteResolution(matrix.R);
var points = new List <Vector>();
for (var x = 0; x < matrix.R; x++)
{
for (var y = 0; y < matrix.R; y++)
{
for (var z = 0; z < matrix.R; z++)
{
var vector = new Vector(x, y, z);
if (matrix.IsFull(vector))
{
points.Add(vector);
}
}
}
}
var queue = new Queue <Vector>(points);
while (queue.Any())
{
var part = queue.Dequeue(1000);
oplogWriter.WriteGroupAdd(part);
}
oplogWriter.Save();
}
public static void SearchTest()
{
//var trackFilePath = @"..\..\..\data\track\LA001.nbt";
var modelFilePath = @"..\..\..\data\models\LA180_tgt.mdl";
var matrix = MatrixDeserializer.Deserialize(File.ReadAllBytes(modelFilePath));
//var ai = new GreedyGravityAI(matrix);
Console.WriteLine("matrix loaded");
var mongoOplogWriter = new JsonOpLogWriter(new MongoJsonWriter());
mongoOplogWriter.WriteLogName("GreedyGravityAI_IsGrounded");
var state = State.CreateInitial(matrix.R, mongoOplogWriter);
mongoOplogWriter.WriteInitialState(state);
var groundedChecker = new IsGroundedChecker(matrix);
var startPosition = new Vector(0, 0, 0);
for (int i = 0; i < matrix.R; i++)
{
for (int j = 0; j < matrix.R; j++)
{
for (int k = 0; k < matrix.R; k++)
{
var vector = new Vector(i, j, k);
if (matrix.IsVoid(vector))
{
continue;
}
mongoOplogWriter.WriteColor(vector, "0000FF", 0.5);
}
}
}
Console.WriteLine("matrix inited");
var rand = new Random(15);
var forbidden = new HashSet <Vector>();
Console.WriteLine("start");
for (int i = 0; i < 1002; i++)
{
var endPosition = new Vector(rand.Next(matrix.R), rand.Next(matrix.R), rand.Next(matrix.R));
while (forbidden.Contains(endPosition) || matrix.IsFull(endPosition))
{
endPosition = new Vector(rand.Next(matrix.R), rand.Next(matrix.R), rand.Next(matrix.R));
}
mongoOplogWriter.WriteColor(endPosition, "00FF00", 1);
DateTime d = DateTime.UtcNow;
var pathBuilder = new BotMoveSearcher(matrix, state.Matrix, startPosition, vector => forbidden.Contains(vector), 39, endPosition, groundedChecker);
pathBuilder.FindPath(out var movePath, out var commands, out var iterations);
if (movePath == null)
{
break;
}
Console.WriteLine($"{commands.Count}: {d - DateTime.UtcNow} - {iterations}");
movePath.ForEach(c => forbidden.Add(c));
foreach (var vector in movePath)
{
mongoOplogWriter.WriteFill(vector);
}
mongoOplogWriter.WriteColor(endPosition, "0000FF", 1);
startPosition = endPosition;
}
mongoOplogWriter.Save();
}
public GreedyFiller(Matrix matrix, HashSet <Vector> figure, JsonOpLogWriter mongoOplogWriter)
{
this.mongoOplogWriter = mongoOplogWriter;
this.figure = figure;
this.matrix = matrix;
}
public static void Main(string[] args)
{
var srcModelPath = @"..\..\..\data\problemsF\FR002_src.mdl";
var tgtModelPath = @"..\..\..\data\problemsF\FR002_tgt.mdl";
var sourceMatrix = MatrixDeserializer.Deserialize(File.ReadAllBytes(srcModelPath));
var targetMatrix = MatrixDeserializer.Deserialize(File.ReadAllBytes(tgtModelPath));
// sourceMatrix = new Matrix(targetMatrix.R);
var mongoOplogWriter = new JsonOpLogWriter(new MongoJsonWriter());
mongoOplogWriter.WriteLogName("FigureDecomposer");
var state = State.CreateInitial(sourceMatrix.R, mongoOplogWriter);
mongoOplogWriter.WriteInitialState(state);
var tasks = new FigureDecomposer(targetMatrix, sourceMatrix).Decompose();
var fillPoints = new List <Vector>();
var voidPoints = new List <Vector>();
var rand = new Random();
foreach (var task in tasks)
{
if (task.Type == BuildingTaskType.GFill || task.Type == BuildingTaskType.GVoid)
{
var points = new List <Vector>();
for (var x = task.Region.Min.X; x <= task.Region.Max.X; x++)
{
for (var y = task.Region.Min.Y; y <= task.Region.Max.Y; y++)
{
for (var z = task.Region.Min.Z; z <= task.Region.Max.Z; z++)
{
points.Add(new Vector(x, y, z));
}
}
}
var fill = task.Type == BuildingTaskType.GFill;
mongoOplogWriter.WriteGroupColor(points.ToArray(),
fill ? $"00FF{rand.Next(10, 99)}" : $"FF00{rand.Next(10, 99)}", fill ? 0.8 : 0.5);
}
else if (task.Type == BuildingTaskType.Fill || task.Type == BuildingTaskType.Void)
{
if (task.Type == BuildingTaskType.Fill)
{
fillPoints.Add(task.Region.Min);
}
else
{
voidPoints.Add(task.Region.Min);
}
}
}
mongoOplogWriter.WriteGroupColor(fillPoints.ToArray(), "0000FF", 0.8);
mongoOplogWriter.WriteGroupColor(voidPoints.ToArray(), "FFFF00", 0.5);
mongoOplogWriter.Save();
Console.WriteLine("Saved to MongoDB");
Console.ReadLine();
}
private List <ICommand> FillFigure(HashSet <Vector> figure, HashSet <Vector> prohibited,
Vector start)
{
if (figure.Intersect(prohibited).Count() > 0)
{
throw new ArgumentException("`figure` should not intersect `prohibited`");
}
if (!figure.Contains(start))
{
throw new ArgumentException("`figure` should contain `start` and `end`");
}
var gravity = CalcGravity(figure, start);
var mongoOplogWriter = new JsonOpLogWriter(new MongoJsonWriter());
mongoOplogWriter.WriteLogName("GreedyGravityAI_Expected");
var state = State.CreateInitial(targetMatrix.R, mongoOplogWriter);
mongoOplogWriter.WriteInitialState(state);
Console.WriteLine("figure.Count = {0}", figure.Count);
Console.WriteLine("gravity.Count = {0}", gravity.Count);
figure = gravity.Keys.ToHashSet(); // FIXME: It's a hack for non-connected figures
int i = 0;
var removeFills = new Queue <Vector>();
var filled = new HashSet <Vector>();
var curPoint = start;
var volatiles = new List <Vector>();
var commands = new List <ICommand>();
while (filled.Count < figure.Count)
{
var nextPoint = curPoint.GetAdjacents()
.Where(p => figure.Contains(p) && !filled.Contains(p))
.OrderByDescending(p => gravity[p])
.FirstOrDefault();
if (nextPoint == null)
{
nextPoint = figure.Where(p => p != curPoint && !filled.Contains(p))
.OrderBy(p => (curPoint - p).Mlen)
.ThenByDescending(p => gravity[p])
.FirstOrDefault();
if (nextPoint != null)
{
mongoOplogWriter.WriteColor(curPoint, "0000FF", 0.5);
mongoOplogWriter.WriteColor(nextPoint, "00FF00", 0.5);
}
}
else
{
mongoOplogWriter.WriteColor(nextPoint, "FF0000", 0.5);
}
if (nextPoint == null)
{
nextPoint = new Vector(0, 0, 0);
}
try
{
List <Vector> curPath;
List <ICommand> curCommands;
if (!curPoint.IsAdjacentTo(nextPoint))
{
Move(figure, prohibited, curPoint, nextPoint, CommandType.Fill, out curPath, out curCommands);
}
else
{
curPath = new List <Vector>
{
nextPoint
};
curCommands = new List <ICommand>
{
new SMoveCommand(nextPoint - curPoint),
new FillCommand(curPoint - nextPoint, curPoint),
};
}
foreach (var vector in curPath.Where(vector => filled.Contains(vector)))
{
removeFills.Enqueue(vector);
mongoOplogWriter.WriteColor(vector, "FFFF00", 0.5);
}
filled.Add(curPoint);
volatiles.AddRange(curPath);
commands.AddRange(curCommands);
} catch (ArgumentException)
{
Console.WriteLine("Exception, was able to draw only {0} points", filled.Count);
break;
}
curPoint = nextPoint;
}
mongoOplogWriter.Save();
commands.Add(new HaltCommand());
Console.WriteLine("Commands have been generated");
commands = commands.Where(command =>
{
var fillCommand = command as FillCommand;
if (fillCommand == null)
{
return(true);
}
if (!fillCommand.RealFill.Equals(removeFills.Peek()))
{
return(true);
}
removeFills.Dequeue();
return(false);
}).ToList();
return(commands);
}
