protected void BeginTest(string mapName, int playersCount)
{
m_abilities = new Dictionary <int, VoxelAbilities[]>();
m_players = new Guid[playersCount];
for (int i = 0; i < m_players.Length; ++i)
{
m_players[i] = Guid.NewGuid();
m_abilities.Add(i, CreateTemporaryAbilies());
}
string dataPath = Application.streamingAssetsPath + "/Maps/";
string filePath = dataPath + mapName;
m_replay = MatchFactory.CreateReplayRecorder();
Dictionary <int, VoxelAbilities>[] allAbilities = new Dictionary <int, VoxelAbilities> [m_players.Length];
for (int i = 0; i < m_players.Length; ++i)
{
allAbilities[i] = m_abilities[i].ToDictionary(a => a.Type);
}
MapData mapData = m_protobufSerializer.Deserialize <MapData>(File.ReadAllBytes(filePath));
m_map = m_protobufSerializer.Deserialize <MapRoot>(mapData.Bytes);
m_engine = MatchFactory.CreateMatchEngine(m_map, playersCount);
for (int i = 0; i < m_players.Length; ++i)
{
m_engine.RegisterPlayer(m_players[i], i, allAbilities);
}
m_engine.CompletePlayerRegistration();
}
public MatchService(IMatchmakingService matchmakingService, IMatchEngine matchEngine, IMatchRepository matchRepository, IBus bus)
{
_matchmakingService = matchmakingService;
_matchEngine = matchEngine;
_matchRepository = matchRepository;
_bus = bus;
}
public static IMatchUnitController CreateUnitController(IMatchEngine engine, Coordinate coordinate, int type, int playerIndex, Dictionary <int, VoxelAbilities>[] allAbilities)
{
IVoxelDataController dataController = CreateVoxelDataController(engine.Map, coordinate, type, playerIndex, allAbilities);
if (type == (int)KnownVoxelTypes.Eater)
{
return(new VoxelActorUnitController(dataController, engine));
}
else if (type == (int)KnownVoxelTypes.Bomb)
{
return(new VoxelBombUnitController(dataController, engine));
}
else if (type == (int)KnownVoxelTypes.Spawner)
{
return(new SpawnerUnitController(dataController));
}
else if ((type & (int)KnownVoxelTypes.Preview) != 0)
{
return(new PreviewUnitController(dataController));
}
else
{
throw new System.NotSupportedException(string.Format("Type {0} is not supported", type));
}
}
public MatchPlayerController(IMatchEngine engine, int playerIndex, Dictionary <int, VoxelAbilities>[] allAbilities)
{
m_playerIndex = playerIndex;
m_engine = engine;
m_allAbilities = allAbilities;
m_engine.Map.Root.ForEach(cell =>
{
cell.ForEach(voxelData =>
{
int owner = voxelData.Owner;
if (owner == m_playerIndex)
{
if (VoxelData.IsUnit(voxelData.Type))
{
Coordinate coordinate = new Coordinate(cell, voxelData);
CreateUnitController(voxelData, coordinate);
}
else
{
if (!voxelData.IsNeutral)
{
CreateAsset(voxelData, cell);
}
}
}
});
});
m_units = m_idToUnit.Values.ToArray();
m_commandBuffer = new CommandsArray(new Cmd[m_idToUnit.Count]);
}
public BotControlManager(ITimeService time, IMatchEngine engine, Player[] players, Guid[] clientIds)
{
m_engine = engine;
m_time = time;
m_players = players;
m_clientIds = clientIds;
}
public virtual void Tick(IMatchEngine engine, long tick)
{
while (m_ticks.Count > 0 && m_ticks.Peek() == tick)
{
Cmd cmd = m_commands.Dequeue();
int playerIndex = m_playerIndices.Dequeue();
m_ticks.Dequeue();
engine.Submit(playerIndex, cmd);
}
}
public void Destroy()
{
enabled = false;
int index = m_room.Players.IndexOf(m_neutralPlayer.Id);
if (index >= 0)
{
m_room.Players.RemoveAt(index);
m_clientIds.RemoveAt(index);
}
if (m_engine != null)
{
m_engine.OnSubmitted -= OnEngineCommandSubmitted;
MatchFactory.DestroyMatchEngine(m_engine);
m_engine = null;
}
}
public static IMatchPlayerController CreatePlayerController(IMatchEngine engine, int playerIndex, Dictionary <int, VoxelAbilities>[] allAbilities)
{
return(new MatchPlayerController(engine, playerIndex, allAbilities));
}
public static void DestroyMatchEngine(IMatchEngine engine)
{
engine.Destroy();
}
private void InitEngine(Guid clientId, ServerEventHandler callback)
{
if (m_engine != null)
{
MatchFactory.DestroyMatchEngine(m_engine);
}
m_engine = null;
DownloadMapData(m_room.MapInfo.Id, (error, mapData) =>
{
if (HasError(error))
{
if (callback != null)
{
callback(error);
}
}
else
{
m_job.Submit(() =>
{
ProtobufSerializer serializer = null;
MapRoot mapRoot = null;
try
{
var pool = Dependencies.Serializer;
if (pool != null)
{
serializer = pool.Acquire();
mapRoot = serializer.Deserialize <MapRoot>(mapData.Bytes);
}
}
finally
{
if (serializer != null)
{
var pool = Dependencies.Serializer;
if (pool != null)
{
pool.Release(serializer);
}
}
}
return(mapRoot);
},
result =>
{
MapRoot mapRoot = (MapRoot)result;
IMatchEngine engine = MatchFactory.CreateMatchEngine(mapRoot, m_room.Players.Count);
Dictionary <int, VoxelAbilities>[] allAbilities = new Dictionary <int, VoxelAbilities> [m_room.Players.Count];
for (int i = 0; i < m_room.Players.Count; ++i)
{
allAbilities[i] = m_abilities[m_room.Players[i]].ToDictionary(a => a.Type);
}
if (m_replay == null)
{
m_replay = MatchFactory.CreateReplayRecorder();
}
//Zero is neutral
for (int i = 0; i < m_room.Players.Count; ++i)
{
Guid playerGuid = m_room.Players[i];
engine.RegisterPlayer(m_room.Players[i], i, allAbilities);
}
engine.CompletePlayerRegistration();
m_prevTickTime = Time.realtimeSinceStartup;
m_engine = engine;
if (callback != null)
{
callback(error);
}
m_pingTimer.Ping(clientId);
if (Ping != null)
{
Ping(new Error(StatusCode.OK), new RTTInfo());
}
});
}
});
}
private void InitEngine(ServerEventHandler callback)
{
m_initializationStarted = true;
DownloadMapData((Error error, MapData mapData) =>
{
m_initializationStarted = false;
if (HasError(error))
{
if (callback != null)
{
callback(error);
}
}
else
{
MapRoot mapRoot = m_serializer.Deserialize <MapRoot>(mapData.Bytes);
IMatchEngine engine = MatchFactory.CreateMatchEngine(mapRoot, m_room.Players.Count);
Dictionary <int, VoxelAbilities>[] allAbilities = new Dictionary <int, VoxelAbilities> [m_room.Players.Count];
for (int i = 0; i < m_room.Players.Count; ++i)
{
allAbilities[i] = m_abilities[m_room.Players[i]].ToDictionary(a => a.Type);
}
if (m_replay == null)
{
m_replay = MatchFactory.CreateReplayRecorder();
}
//Zero is neutral
for (int i = 0; i < m_room.Players.Count; ++i)
{
Guid playerGuid = m_room.Players[i];
engine.RegisterPlayer(m_room.Players[i], i, allAbilities);
}
engine.CompletePlayerRegistration();
if (m_engine != null)
{
m_engine.OnSubmitted -= OnEngineCommandSubmitted;
}
m_engine = engine;
m_engine.OnSubmitted += OnEngineCommandSubmitted;
if (callback != null)
{
callback(error);
}
if (m_room.Mode != GameMode.Replay)
{
m_pingTimer.PingAll();
if (Ping != null)
{
m_pingArgs.Arg = new RTTInfo();
m_pingArgs.Except = Guid.Empty;
Ping(new Error(StatusCode.OK), m_pingArgs);
}
}
else
{
OnPingPongCompleted(new Error(StatusCode.OK), m_room.CreatorClientId);
}
}
});
}
public VoxelBombUnitController(IVoxelDataController dataController, IMatchEngine engine)
: base(dataController, engine)
{
}
public VoxelActorUnitController(IVoxelDataController dataController, IMatchEngine engine)
: base(dataController)
{
m_engine = engine;
m_pathFinder = m_engine.GetPathFinder(dataController.PlayerIndex);
}
public ImageMatchProvider(IMatchEngine <IImageData, ImageMatch> matchEngine)
{
_matchEngine = matchEngine;
}
public override void Tick(IMatchEngine engine, long tick)
{
}
