public Neuron(ProcessorContainer pc)
{
if (pc == null)
{
throw new ArgumentNullException();
}
if (pc.Count > char.MaxValue)
{
throw new ArgumentException();
}
_procNames = new Dictionary <char, char>(pc.Count);
ProcessorHandler ph = new ProcessorHandler();
StringBuilder sb = new StringBuilder(pc.Count);
for (char k = char.MinValue; k < pc.Count; ++k)
{
if (!ph.Add(ProcessorHandler.RenameProcessor(pc[k], new string(k, 1))))
{
continue;
}
char c = char.ToUpper(pc[k].Tag[0]);
_procNames[c] = k;
sb.Append(c);
}
_processorContainer = ph.Processors;
_workReflex = new Reflex(_processorContainer);
_stringQuery = sb.ToString();
}
public Neuron(ProcessorContainer pc)
{
ProcessorHandler ph = FromProcessorContainer(pc);
_workReflex = new Reflex(ph.Processors);
_procNames = ph.ToHashSet();
_stringOriginalUniqueQuery = ph.ToString();
}
public void Test1()
{
ProcessorHandler ph = new ProcessorHandler();
Assert.AreEqual(true, ph.IsEmpty);
Assert.AreEqual(0, ph.Count);
bool bex = false;
try
{
ProcessorContainer unused = ph.Processors;
}
catch (Exception ex)
{
Assert.AreEqual(typeof(Exception), ex.GetType());
Assert.AreEqual($"{nameof(ProcessorHandler)}: Список карт пуст.", ex.Message);
bex = true;
}
Assert.AreEqual(true, bex);
ph.Add(new Processor(new[] { new SignValue(2) }, "A"));
Assert.AreEqual(false, ph.IsEmpty);
Assert.AreEqual(1, ph.Count);
ph.AddRange(new[] { new Processor(new[] { new SignValue(3) }, "b"), new Processor(new[] { new SignValue(4) }, "C") });
Assert.AreEqual(false, ph.IsEmpty);
Assert.AreEqual(3, ph.Count);
ProcessorContainer procs = ph.Processors;
Assert.AreNotEqual(null, procs);
Assert.AreEqual(new SignValue(2), procs[0][0, 0]);
Assert.AreEqual("A", procs[0].Tag);
Assert.AreEqual(new SignValue(3), procs[1][0, 0]);
Assert.AreEqual("b", procs[1].Tag);
Assert.AreEqual(new SignValue(4), procs[2][0, 0]);
Assert.AreEqual("C", procs[2].Tag);
Assert.AreEqual(3, procs.Count);
string str = ph.ToString();
const string myStr = "AbC";
Assert.AreEqual(myStr, str);
HashSet <char> chs = ph.ToHashSet();
Assert.AreNotEqual(null, chs);
HashSet <char> chj = new HashSet <char>(myStr);
Assert.AreNotEqual(null, chj);
Assert.AreEqual(true, chs.SetEquals(chj));
}
public MigrationEngineCore(IHost host, ILogger <MigrationEngineCore> log, ITelemetryLogger telemetry, IEngineConfigurationBuilder configBuilder)
{
_Host = host;
_Log = log;
_Telemetry = telemetry;
_Config = configBuilder.BuildFromFile();
_witdContainer = _Host.Services.GetRequiredService <TypeDefinitionMapContainer>();
_pContainer = _Host.Services.GetRequiredService <ProcessorContainer>();
_grmContainer = _Host.Services.GetRequiredService <GitRepoMapContainer>();
ProcessConfiguration();
}
public void SetProcessor(EEGProcessor processor, bool create)
{
if (processorContainer == null && create)
{
GameObject go = new GameObject();
processorContainer = go.AddComponent <ProcessorContainer> ();
}
if (processorContainer != null)
{
processorContainer.processor = processor;
}
}
static ProcessorContainer CopyContainer(ProcessorContainer pc)
{
if (pc == null)
{
throw new ArgumentNullException();
}
ProcessorContainer copy = new ProcessorContainer(pc[0]);
for (int k = 1; k < pc.Count; k++)
{
copy.Add(pc[k]);
}
return(copy);
}
public MigrationEngine(EngineConfiguration config,
TypeDefinitionMapContainer typeDefinitionMaps,
ProcessorContainer processors,
GitRepoMapContainer gitRepoMaps,
ChangeSetMappingContainer changeSetMapps,
ITelemetryLogger telemetry)
{
Log.Information("Creating Migration Engine {Guid}", _Guid);
TypeDefinitionMaps = typeDefinitionMaps;
Processors = processors;
GitRepoMaps = gitRepoMaps;
ChangeSetMapps = changeSetMapps;
Telemetry = telemetry;
ProcessConfiguration(config);
}
static ProcessorHandler FromProcessorContainer(ProcessorContainer pc)
{
if (pc == null)
{
throw new ArgumentNullException();
}
ProcessorHandler ph = new ProcessorHandler();
for (int k = 0; k < pc.Count; k++)
{
ph.Add(pc[k]);
}
return(ph);
}
public void ProcessorContainerTest()
{
var config = CreateEngineConfiguration();
var testSimple = new SimpleProcessorConfigMock();
Assert.AreEqual(0, config.Processors.Count);
testSimple.Enabled = true;
config.Processors.Add(testSimple);
Assert.AreEqual(1, config.Processors.Count);
var processorContainer = new ProcessorContainer(CreateServiceProvider(), config);
Assert.AreEqual(1, processorContainer.Count);
}
static void CheckProcessorHandler2(ProcessorHandler ph)
{
Assert.AreNotEqual(null, ph);
ProcessorContainer procs = new ProcessorContainer(ph.Processors.ToArray());
Assert.AreNotEqual(null, procs);
Assert.AreEqual(procs.Width, 1);
Assert.AreEqual(procs.Height, 1);
Assert.AreEqual(3, procs.Count);
Assert.AreEqual(new SignValue(2), procs[0][0, 0]);
Assert.AreEqual("A", procs[0].Tag);
Assert.AreEqual(new SignValue(3), procs[1][0, 0]);
Assert.AreEqual("b", procs[1].Tag);
Assert.AreEqual(new SignValue(4), procs[2][0, 0]);
Assert.AreEqual("C", procs[2].Tag);
Assert.AreEqual("ABC", ph.ToString());
}
/// <summary>
/// Инициализирует текущий экземпляр <see cref="DynamicReflex" /> картами из указанного экземпляра
/// <see cref="ProcessorContainer" />.
/// Карты предназначены для вызова <see cref="DynamicParser.Processor.GetEqual(ProcessorContainer)" />.
/// Этот список невозможно изменить вручную, в процессе работы с классом.
/// </summary>
/// <param name="processors">
/// Карты, которые необходимо добавить в текущий экземпляр <see cref="DynamicReflex" />.
/// С помощью них будет проводиться поиск запрашиваемых данных.
/// </param>
public DynamicReflex(ProcessorContainer processors)
{
if (processors == null)
{
throw new ArgumentNullException(nameof(processors), $"{nameof(DynamicReflex)}: Карты должны быть добавлены в контекст (null).");
}
Processor[] procs = new Processor[processors.Count];
for (int k = 0; k < procs.Length; k++)
{
Processor p = processors[k];
_setChars.Add(char.ToUpper(p.Tag[0]));
procs[k] = p;
}
_seaProcessors = new ProcessorContainer(procs);
}
/// <summary>
/// Добавляет карты в коллекцию, проверяя их на предмет совпадающих значений свойств <see cref="Processor.Tag" />.
/// Добавление производится в общую коллекцию для ускорения поиска.
/// </summary>
/// <param name="pc">Коллекция добавляемых карт.</param>
protected void CopyProcessorContainer(ProcessorContainer pc)
{
if (pc == null)
{
throw new ArgumentNullException(nameof(pc),
$"{nameof(CopyProcessorContainer)}: Коллекция добавляемых карт отсутствует (null).");
}
for (int k = 0; k < pc.Count; k++)
{
Processor p = pc[k];
char tag = char.ToUpper(p.Tag[0]);
if (_processors.ContainsKey(tag))
{
throw new ArgumentException(
$"{nameof(CopyProcessorContainer)}: Обнаружены повторяющиеся карты: карта с таким названием ({tag}) уже была добавлена.",
nameof(pc));
}
_processors[tag] = p;
}
}
public MigrationEngine(
IServiceProvider services,
ExecuteOptions executeOptions,
EngineConfiguration config,
TypeDefinitionMapContainer typeDefinitionMaps,
ProcessorContainer processors,
GitRepoMapContainer gitRepoMaps,
ChangeSetMappingContainer changeSetMapps,
FieldMapContainer fieldMaps,
ITelemetryLogger telemetry)
{
Log.Information("Creating Migration Engine {Guid}", _Guid);
_services = services;
FieldMaps = fieldMaps;
this.executeOptions = executeOptions;
TypeDefinitionMaps = typeDefinitionMaps;
Processors = processors;
GitRepoMaps = gitRepoMaps;
ChangeSetMapps = changeSetMapps;
Telemetry = telemetry;
Config = config;
}
public MigrationEngine(
IServiceProvider services,
IOptions <NetworkCredentialsOptions> networkCredentials,
EngineConfiguration config,
TypeDefinitionMapContainer typeDefinitionMaps,
ProcessorContainer processors,
GitRepoMapContainer gitRepoMaps,
ChangeSetMappingContainer changeSetMapps,
FieldMapContainer fieldMaps,
ITelemetryLogger telemetry)
{
Log.Information("Creating Migration Engine {SessionId}", telemetry.SessionId);
_services = services;
FieldMaps = fieldMaps;
_networkCredentials = networkCredentials.Value;
TypeDefinitionMaps = typeDefinitionMaps;
Processors = processors;
GitRepoMaps = gitRepoMaps;
ChangeSetMapps = changeSetMapps;
Telemetry = telemetry;
Config = config;
}
/// <summary>
/// Инициализирует текущий экземпляр класса, добавляя указанные карты в коллекцию класса, создавая её копию. Массив
/// <see cref="ProcessorContainer" /> не может быть пустым или равен <see langword="null" />.
/// Производится проверка на отсутствие карт с одинаковыми значениями свойств <see cref="Processor.Tag" />, также
/// необходимо, чтобы все объекты <see cref="ProcessorContainer" /> были одинакового размера.
/// Количество карт в объектах <see cref="ProcessorContainer" /> должно быть не менее двух, а их свойства
/// <see cref="Processor.Tag" /> состояли не более, чем из одного символа.
/// Объекты <see cref="ProcessorContainer" /> не могут быть равны <see langword="null" />.
/// </summary>
/// <param name="processors">Карты, которые требуется распознать.</param>
public Reflector(ProcessorContainer[,] processors)
{
if (!IsOneSize(processors))
{
throw new ArgumentException(
$"{nameof(Reflector)}: Искомые карты не прошли проверку на размер и/или количество карт в массиве, а также на значение null или значение свойства {nameof(Processor.Tag)}.",
nameof(processors));
}
int lx = processors.GetLength(0), ly = processors.GetLength(1);
_processorContainers = new ProcessorContainer[lx, ly];
for (int y = 0; y < ly; y++)
{
for (int x = 0; x < lx; x++)
{
ProcessorContainer pc = processors[x, y];
_processorContainers[x, y] = CopyContainer(pc);
CopyProcessorContainer(pc);
}
}
MapHeight = processors[0, 0].Height;
MapWidth = processors[0, 0].Width;
}
/// <summary>
/// Возвращает все варианты запросов для распознавания какой-либо карты.
/// </summary>
/// <param name="processors">Массив карт для чтения первых символов их названий. Остальные символы игнорируются.</param>
/// <returns>Возвращает все варианты запросов для распознавания какой-либо карты.</returns>
protected static IEnumerable <char[, ]> Matrixes(ProcessorContainer[,] processors)
{
if (processors == null)
{
throw new ArgumentNullException(nameof(processors), $"{nameof(Matrixes)}: Массив карт равен null.");
}
int mx = processors.GetLength(0), my = processors.GetLength(1);
if (mx <= 0)
{
throw new ArgumentException($"{nameof(Matrixes)}: Массив карт пустой (ось X).", nameof(processors));
}
if (my <= 0)
{
throw new ArgumentException($"{nameof(Matrixes)}: Массив карт пустой (ось Y).", nameof(processors));
}
int[] count = new int[processors.Length];
do
{
char[,] ch = new char[mx, my];
for (int y = 0, cy = my - 1; y < my; y++, cy--)
{
for (int x = 0, cx = mx - 1; x < mx; x++, cx--)
{
ProcessorContainer pc = processors[x, y];
if (pc == null)
{
throw new ArgumentNullException(nameof(processors),
$"{nameof(Matrixes)}: Элемент массива карт отсутствует (null).");
}
ch[x, y] = pc[count[cy * mx + cx]].Tag[0];
}
}
yield return(ch);
} while (ChangeCount(count, processors));
}
/// <summary>
/// Выполняет проверку указанного массива объектов <see cref="ProcessorContainer" /> без их изменения.
/// Необходимо, чтобы все объекты <see cref="ProcessorContainer" /> были одинакового размера. Массив
/// <see cref="ProcessorContainer" /> не может быть пустым или равен <see langword="null" />.
/// Количество карт в каждом объекте <see cref="ProcessorContainer" /> должно быть не менее двух, а их свойства
/// <see cref="Processor.Tag" /> состояли не более, чем из одного символа.
/// Объекты <see cref="ProcessorContainer" /> не могут быть равны <see langword="null" />.
/// </summary>
/// <param name="processors">Проверяемые карты.</param>
/// <returns>
/// В случае успеха возвращает значение <see langword="true" />, в противном случае возвращает значение
/// <see langword="false" />.
/// </returns>
protected static bool IsOneSize(ProcessorContainer[,] processors)
{
if (processors == null)
{
throw new ArgumentNullException(nameof(processors),
$"{nameof(IsOneSize)}: Проверяемые карты отсутствуют (null).");
}
if (processors.GetLength(0) <= 0)
{
throw new ArgumentException($"{nameof(IsOneSize)}: Массив проверяемых карт пустой (ось X).",
nameof(processors));
}
if (processors.GetLength(1) <= 0)
{
throw new ArgumentException($"{nameof(IsOneSize)}: Массив проверяемых карт пустой (ось Y).",
nameof(processors));
}
ProcessorContainer fpc = processors[0, 0];
if (fpc == null)
{
throw new ArgumentNullException(nameof(processors),
$"{nameof(IsOneSize)}: Первый проверяемый массив карт равен null.");
}
if (fpc.Count < 2)
{
throw new ArgumentException(
$"{nameof(IsOneSize)}: В первом проверяемом массиве менее двух карт ({fpc.Count}).",
nameof(processors));
}
int cx = fpc.Width;
int cy = fpc.Height;
for (int y = 0, my = processors.GetLength(1); y < my; y++)
{
for (int x = 0, mx = processors.GetLength(0); x < mx; x++)
{
ProcessorContainer pc = processors[x, y];
if (pc == null)
{
throw new ArgumentNullException(nameof(processors),
$"{nameof(IsOneSize)}: Обнаружен контейнер, равный null.");
}
if (pc.Count < 2)
{
throw new ArgumentException(
$"{nameof(IsOneSize)}: Обнаружен контейнер, в котором менее двух карт ({pc.Count}).",
nameof(processors));
}
for (int k = 0; k < pc.Count; k++)
{
if (pc[k].Tag.Length != 1)
{
throw new ArgumentException(
$"{nameof(IsOneSize)}: Обнаружен контейнер, в котором название карты состоит более или менее, чем из одного символа ({pc[k].Tag.Length}): ({pc[k].Tag}).",
nameof(processors));
}
}
if (pc.Width != cx || pc.Height != cy)
{
return(false);
}
}
}
return(true);
}
// Update is called once per frame
void Update()
{
if (!started)
{
processorContainer = FindObjectOfType <ProcessorContainer> ();
if ((processorContainer != null && processorContainer.processor != null))
{
EEGManager.Instance.Processor = processorContainer.processor;
EEGManager.Instance.Trained = true;
Status = GameStatus.Playing;
}
else
{
Status = GameStatus.Training;
}
started = true;
}
switch (status)
{
case GameStatus.Playing:
if (Input.GetKeyDown(KeyCode.P))
{
Status = GameStatus.Paused;
return;
}
if (player.health <= 0)
{
Status = GameStatus.GameOver;
return;
}
EyesStatus status = EEGManager.Instance.Status;
if (status == EyesStatus.CLOSED)
{
if (previousStatus == EyesStatus.OPEN)
{
visibilityOn = false;
foreach (OutlineObject visibleObject in activeObjects)
{
visibleObject.Outline = false;
}
inactiveObjects.UnionWith(activeObjects);
activeObjects.Clear();
}
visibilityTime += Time.deltaTime;
if (checkingTimer.Finished)
{
checkingTimer.Reset();
foreach (Bomb bomb in bombs)
{
float distance = Vector3.Distance(player.transform.position, bomb.transform.position);
if (distance <= hearingDistance)
{
if (!activeBombs.Contains(bomb))
{
bomb.PlayBeepSound();
activeBombs.Add(bomb);
}
}
else
{
if (activeBombs.Contains(bomb))
{
activeBombs.Remove(bomb);
bomb.StopPlaying();
}
}
}
foreach (OutlineObject inactiveObject in inactiveObjects)
{
float distance = Vector3.Distance(player.transform.position, inactiveObject.transform.position);
if (distance <= hearingDistance)
{
activeObjects.Add(inactiveObject);
}
}
inactiveObjects.RemoveWhere(x => activeObjects.Contains(x));
}
}
else
{
foreach (Bomb bomb in activeBombs)
{
bomb.StopPlaying();
}
activeBombs.Clear();
if (previousStatus == EyesStatus.CLOSED)
{
visibilityTimer = new CounterTimer(Mathf.Min(visibilityTime + EEGManager.Instance.minThreshold, maxVisibilityDuration));
foreach (OutlineObject activeObject in activeObjects)
{
activeObject.Outline = true;
}
visibilityOn = true;
}
else
{
if (visibilityOn && visibilityTimer.Finished)
{
visibilityOn = false;
foreach (OutlineObject activeObject in activeObjects)
{
activeObject.Outline = false;
}
inactiveObjects.UnionWith(activeObjects);
activeObjects.Clear();
}
}
if (visibilityOn)
{
visibilityTimer.Update(Time.deltaTime);
}
visibilityTime = 0;
}
previousStatus = status;
checkingTimer.Update(Time.deltaTime);
break;
case GameStatus.Paused:
if (Input.GetKeyDown(KeyCode.P))
{
Status = GameStatus.Playing;
return;
}
break;
case GameStatus.Training:
if (Input.GetKey(KeyCode.K))
{
EEGManager.Instance.StopTraining();
}
break;
default:
break;
}
}