protected override void StartOverride()
{
base.StartOverride();
m_engine = Dependencies.MatchEngine;
m_animateFromPosition = transform.position;
m_animateToPosition = transform.position;
if (m_primaryMaterial == null)
{
Debug.LogError("Set inner material");
return;
}
if (m_animator == null)
{
m_animator = GetComponentInParent <Animator>();
if (m_animator == null)
{
Debug.LogError("Set animator");
return;
}
}
}
private void Awake()
{
m_engine = Dependencies.MatchEngine;
m_unitSelection = Dependencies.UnitSelection;
m_targetSelection = Dependencies.TargetSelection;
m_inputManager = Dependencies.InputManager;
m_map = Dependencies.Map;
m_gameState = Dependencies.GameState;
if (m_commandsPanel != null)
{
m_commandsPanel.Move += OnMove;
m_commandsPanel.Attack += OnAttack;
m_commandsPanel.Cancel += OnCancel;
m_commandsPanel.Auto += OnAuto;
m_commandsPanel.Wall += OnWall;
m_commandsPanel.Bomb += OnBomb;
m_commandsPanel.Spawner += OnSpawner;
m_commandsPanel.Split += OnSplit;
m_commandsPanel.Split4 += OnSplit4;
m_commandsPanel.Grow += OnGrow;
m_commandsPanel.Diminish += OnDiminish;
}
// m_commandsPanel.Closed += OnClosed;
}
private void Awake()
{
m_progress = Dependencies.Progress;
m_notification = Dependencies.Notification;
m_voxelMap = Dependencies.Map;
m_gameView = Dependencies.GameView;
m_remoteGameServer = Dependencies.RemoteGameServer;
m_gSettings = Dependencies.Settings;
m_console = Dependencies.Console;
m_minimap = Dependencies.Minimap;
m_console.Command += OnConsoleCommand;
m_engine = Dependencies.MatchEngine;
m_engine.ReadyToStart += OnEngineReadyToStart;
m_engine.Started += OnEngineStarted;
m_engine.Error += OnEngineError;
m_engine.Stopped += OnEngineStopped;
m_engine.Ping += OnEnginePing;
m_engine.Paused += OnEnginePaused;
m_engine.ExecuteCommands += OnEngineCommands;
m_engine.Reconnected += OnReconnected;
m_engine.ReconnectFailed += OnReconnectFailed;
INavigation navigation = Dependencies.Navigation;
if (string.IsNullOrEmpty(navigation.PrevSceneName) ||
navigation.PrevSceneName == SceneManager.GetActiveScene().name)
{
if (m_remoteGameServer != null)
{
if (m_remoteGameServer.IsConnectionStateChanging)
{
m_remoteGameServer.ConnectionStateChanged += OnConnectionStateChanged;
}
else
{
OnConnectionStateChanged(new Error(), new ValueChangedArgs <bool>(false, m_remoteGameServer.IsConnected));
}
}
}
else
{
m_gameServer = Dependencies.GameServer;
}
m_progress.IsVisible = true;
}
public IEnumerator FindPathClientSidePreprocessingTest()
{
BeginTest(TestEnv0, 4, 0, () => {
MapRoot map = Dependencies.Map.Map;
IMatchEngineCli matchEngineCli = Dependencies.MatchEngine;
const int playerId = 3;
Coordinate[] coords = map.FindDataOfType((int)KnownVoxelTypes.Eater, playerId);
VoxelData data = map.Get(coords[0]);
Coordinate targetCoordinate = coords[0].Add(-1, -1);
MovementCmd moveCmd = new MovementCmd(CmdCode.Move, data.UnitOrAssetIndex, 0);
moveCmd.Coordinates = new[] { coords[0], targetCoordinate };
MatchEngineCliEvent <long, CommandsBundle> eventHandler = null;
eventHandler = (e, tick, commandsBundle) =>
{
if (commandsBundle.TasksStateInfo != null)
{
TaskStateInfo taskStateInfo = commandsBundle.TasksStateInfo[0];
Assert.AreEqual(taskStateInfo.PlayerId, playerId);
if (taskStateInfo.State == TaskState.Completed)
{
matchEngineCli.ExecuteCommands -= eventHandler;
Coordinate[] newCoords = map.FindDataOfType((int)KnownVoxelTypes.Eater, playerId);
Assert.AreEqual(targetCoordinate, newCoords[0]);
EndTest();
}
else
{
Assert.AreEqual(TaskState.Active, taskStateInfo.State);
}
}
};
matchEngineCli.ExecuteCommands += eventHandler;
TaskInfo taskInfo = new TaskInfo(moveCmd);
taskInfo.RequiresClientSidePreprocessing = true;
matchEngineCli.GetClientTaskEngine(playerId).GenerateIdentitifers(taskInfo);
matchEngineCli.Submit(playerId, new TaskCmd(SerializedTask.FromTaskInfo(taskInfo)));
});
yield return(Run());
}
public IEnumerator FindPathClientSideTaskTest()
{
BeginTest(TestEnv1, 2, 0, () =>
{
MapRoot map = Dependencies.Map.Map;
IMatchEngineCli matchEngineCli = Dependencies.MatchEngine;
const int playerId = 1;
Coordinate[] coords = map.FindDataOfType((int)KnownVoxelTypes.Eater, playerId);
VoxelData data = map.Get(coords[0]);
Coordinate targetCoordinate = coords[0].Add(1, -1);
MovementCmd moveCmd = new MovementCmd(CmdCode.Move, data.UnitOrAssetIndex, 0);
moveCmd.Coordinates = new[] { coords[0], targetCoordinate };
ITaskEngine taskEngine = matchEngineCli.GetClientTaskEngine(playerId);
TaskEngineEvent <TaskInfo> taskStateChanged = null;
taskStateChanged = taskStateInfo =>
{
if (taskStateInfo.State == TaskState.Completed)
{
taskEngine.TaskStateChanged -= taskStateChanged;
Coordinate[] newCoords = map.FindDataOfType((int)KnownVoxelTypes.Eater, playerId);
Assert.AreEqual(targetCoordinate, newCoords[0]);
EndTest();
}
else
{
Assert.AreEqual(TaskState.Active, taskStateInfo.State);
}
};
taskEngine.TaskStateChanged += taskStateChanged;
TaskInfo taskInfo = new TaskInfo(moveCmd, playerId);
taskInfo.RequiresClientSidePreprocessing = true;
taskEngine.SubmitTask(taskInfo);
});
yield return(Run());
}
public override void ReadFrom(VoxelData data)
{
base.ReadFrom(data);
RoundPosition();
m_animateFromPosition = transform.position;
m_animateToPosition = transform.position;
if (m_engine == null)
{
m_engine = Dependencies.MatchEngine;
}
if (VoxelData.Unit == null)
{
VoxelData.Unit = new VoxelUnitData();
}
if (VoxelData.Unit.State == VoxelDataState.Mutating)
{
UpdateProgressUI(false);
}
}
public IEnumerator TaskTest(
int playerId,
Func <TaskInputInfo, TaskInputInfo, TaskInfo> GetTestTaskInfo,
bool shouldTaskBeFailed,
Action <MapRoot> testStarted,
Action <TaskInfo> rootTaskCompleted,
Action <TaskInfo> childTaskCompleted = null,
int unitNumber = 0,
string testEnv = TestEnv2)
{
BeginTest(testEnv, 2, 0, () =>
{
MapRoot map = Dependencies.Map.Map;
testStarted(map);
IMatchEngineCli matchEngineCli = Dependencies.MatchEngine;
Coordinate[] coords = map.FindDataOfType((int)KnownVoxelTypes.Eater, playerId);
VoxelData voxel = map.Get(coords[unitNumber]);
TaskInfo unitIndexTask = TaskInfo.UnitOrAssetIndex(voxel.UnitOrAssetIndex);
TaskInfo playerIndexTask = TaskInfo.EvalExpression(ExpressionInfo.PrimitiveVal(playerId));
TaskInputInfo unitIndexInput = new TaskInputInfo
{
OutputIndex = 0,
OutputTask = unitIndexTask
};
TaskInputInfo playerIndexInput = new TaskInputInfo
{
OutputIndex = 0,
OutputTask = playerIndexTask
};
TaskInfo testTaskInfo = GetTestTaskInfo(unitIndexInput, playerIndexInput);
TaskInfo rootTask = TaskInfo.Procedure(
playerIndexTask,
unitIndexTask,
testTaskInfo,
TaskInfo.Return(ExpressionInfo.TaskStatus(testTaskInfo)));
rootTask.SetParents();
rootTask.Initialize(playerId);
ITaskEngine taskEngine = matchEngineCli.GetClientTaskEngine(playerId);
TaskEngineEvent <TaskInfo> taskStateChanged = null;
taskStateChanged = taskInfo =>
{
if (taskInfo.State == TaskState.Completed)
{
if (taskInfo.TaskId == rootTask.TaskId)
{
Assert.AreEqual(shouldTaskBeFailed, taskInfo.IsFailed, taskInfo.ToString());
taskEngine.TaskStateChanged -= taskStateChanged;
rootTaskCompleted(taskInfo);
EndTest();
}
else
{
if (childTaskCompleted != null)
{
childTaskCompleted(taskInfo);
}
}
}
else if (taskInfo.State != TaskState.Idle)
{
Assert.AreEqual(TaskState.Active, taskInfo.State, taskInfo.ToString());
}
};
taskEngine.TaskStateChanged += taskStateChanged;
taskEngine.SubmitTask(rootTask);
});
yield return(Run());
}
private void Awake()
{
m_matchEngine = Dependencies.MatchEngine;
}
public IEnumerator SearchForFoodTaskTest(int playerId, Action <ITaskEngine, TaskInfo, TaskInfo, Coordinate[]> callback)
{
BeginTest(TestEnv1, 2, 0, () =>
{
MapRoot map = Dependencies.Map.Map;
IMatchEngineCli matchEngineCli = Dependencies.MatchEngine;
Coordinate[] coords = map.FindDataOfType((int)KnownVoxelTypes.Eater, playerId);
VoxelData voxel = map.Get(coords[0]);
TaskInfo searchForFoodTask = new TaskInfo(TaskType.SearchForFood)
{
OutputsCount = 2
};
TaskInputInfo searchForFoodContext = new TaskInputInfo
{
OutputIndex = 0,
OutputTask = searchForFoodTask,
};
TaskInfo getUnitIndexTask = new TaskInfo(TaskType.EvalExpression)
{
Expression = ExpressionInfo.PrimitiveVal(voxel.UnitOrAssetIndex),
OutputsCount = 1
};
TaskInputInfo unitIndex = new TaskInputInfo
{
OutputIndex = 0,
OutputTask = getUnitIndexTask
};
searchForFoodTask.Inputs = new[] { searchForFoodContext, unitIndex };
TaskInfo rootTask = new TaskInfo(TaskType.Sequence)
{
Children = new[] { getUnitIndexTask, searchForFoodTask }
};
rootTask.SetParents();
rootTask.Initialize(playerId);
ITaskEngine taskEngine = matchEngineCli.GetClientTaskEngine(playerId);
TaskEngineEvent <TaskInfo> taskStateChanged = null;
taskStateChanged = taskInfo =>
{
if (taskInfo.State == TaskState.Completed)
{
if (taskInfo.TaskId == searchForFoodTask.TaskId)
{
callback(taskEngine, taskInfo, searchForFoodTask, coords);
}
else if (taskInfo.TaskId == rootTask.TaskId)
{
taskEngine.TaskStateChanged -= taskStateChanged;
EndTest();
}
}
else
{
Assert.AreEqual(TaskState.Active, taskInfo.State);
}
};
taskEngine.TaskStateChanged += taskStateChanged;
taskEngine.SubmitTask(rootTask);
});
yield return(Run());
}
