// Populate lists when we connect
void InitStatics()
{
MaterialTokenList.matTokenList = _netMaterialList.material_list;
TiletypeTokenList.tiletypeTokenList = _netTiletypeList.tiletype_list;
ItemTokenList.itemTokenList = _netItemList.material_list;
MapDataStore.tiletypeTokenList = _netTiletypeList.tiletype_list;
MapDataStore.InitMainMap(_netMapInfo.block_size_x * 16, _netMapInfo.block_size_y * 16, _netMapInfo.block_size_z);
Debug.Log("Materials fetched: " + _netMaterialList.material_list.Count);
Debug.Log("Tiletypes fetched: " + _netTiletypeList.tiletype_list.Count);
Debug.Log("Itemtypes fetched: " + _netItemList.material_list.Count);
Debug.Log("Buildingtypes fetched: " + _netBuildingList.building_list.Count);
Debug.Log("Fetched " + _netRegionMaps.world_maps.Count + " surrounding regions");
Debug.Log("Creature Raws fetched: " + _netCreatureRawList.creature_raws.Count);
}
/// <summary>
/// Performs a single update.
/// </summary>
/// <exception cref="System.Exception"></exception>
void PerformSingleUpdate()
{
//pause df here, so it doesn't try to resume while we're working.
networkClient.SuspendGame();
//everything that controls DF.
#region DF Control
if (mapResetRequested.Pop())
{
mapResetCall.TryExecute();
}
if (digCommandCall != null)
{
while (netDigCommands.Count > 0)
{
digCommandCall.TryExecute(netDigCommands.Dequeue());
}
}
if (setSideMenuCall != null)
{
while (netSidebarSets.Count > 0)
{
setSideMenuCall.TryExecute(netSidebarSets.Dequeue());
}
}
if (pauseCommandCall != null)
{
while (pauseCommands.Count > 0)
{
pauseCommandCall.TryExecute(pauseCommands.Dequeue());
}
}
if (keyboardEventCall != null)
{
KeyboardEvent dfEvent;
while (keyPresses.TryDequeue(out dfEvent))
{
keyboardEventCall.TryExecute(dfEvent);
}
}
if (moveCommandCall != null)
{
while (moveCommands.Count > 0)
{
moveCommandCall.TryExecute(moveCommands.Dequeue());
}
}
if (jumpCommandCall != null)
{
while (jumpCommands.Count > 0)
{
jumpCommandCall.TryExecute(jumpCommands.Dequeue());
}
}
if (movementSelectCommandCall != null)
{
while (carefulMoveCommands.Count > 0)
{
movementSelectCommandCall.TryExecute(carefulMoveCommands.Dequeue());
}
}
if (miscMoveCall != null)
{
while (miscMoveCommands.Count > 0)
{
miscMoveCall.TryExecute(miscMoveCommands.Dequeue());
}
}
#endregion
#region DF Read
if (menuQueryCall != null)
{
AdventureMenuContents = menuQueryCall.Execute();
}
if (getSideMenuCall != null)
{
SidebarState = getSideMenuCall.Execute();
}
if (fetchMap)
{
if (mapInfoCall != null)
{
var mapInfo = mapInfoCall.Execute();
if (mapInfo == null)
{
if (netMapInfo != null)
{
lock (mapInfoLock)
{
embarkMapPosition = new DFCoord(-1, -1, -1);
embarkMapSize = new DFCoord(0, 0, 0);
MapDataStore.InitMainMap(embarkMapSize.x * 16, embarkMapSize.y * 16, embarkMapSize.z);
}
}
}
else
{
if ((netMapInfo == null) ||
mapInfo.block_pos_x != netMapInfo.block_pos_x ||
mapInfo.block_pos_y != netMapInfo.block_pos_y ||
mapInfo.block_pos_z != netMapInfo.block_pos_z ||
mapInfo.block_size_x != netMapInfo.block_size_x ||
mapInfo.block_size_y != netMapInfo.block_size_y ||
mapInfo.block_size_z != netMapInfo.block_size_z)
{
lock (mapInfoLock)
{
embarkMapPosition = new DFCoord(mapInfo.block_pos_x, mapInfo.block_pos_y, mapInfo.block_pos_z);
embarkMapSize = new DFCoord(mapInfo.block_size_x, mapInfo.block_size_y, mapInfo.block_size_z);
MapDataStore.InitMainMap(EmbarkMapSize.x * 16, EmbarkMapSize.y * 16, EmbarkMapSize.z);
mapResetCall.TryExecute();
}
}
}
netMapInfo = mapInfo;
}
if (viewInfoCall != null)
{
ViewInfo viewInfo;
viewInfoCall.TryExecute(null, out viewInfo);
netViewInfo.Set(viewInfo);
}
}
if (fetchScreen)
{
if (copyScreenCall != null)
{
RemoteFortressReader.ScreenCapture screenCapture;
copyScreenCall.TryExecute(null, out screenCapture);
netScreenCapture.Set(screenCapture);
}
}
BlockCoord.Range?requestRangeUpdate = requestRegion.Pop();
if (requestRangeUpdate != null)
{
blockRequest.min_x = requestRangeUpdate.Value.Min.x * GameMap.blockSize / 16;
blockRequest.min_y = requestRangeUpdate.Value.Min.y * GameMap.blockSize / 16;
blockRequest.min_z = requestRangeUpdate.Value.Min.z;
blockRequest.max_x = requestRangeUpdate.Value.Max.x * GameMap.blockSize / 16;
blockRequest.max_y = requestRangeUpdate.Value.Max.y * GameMap.blockSize / 16;
blockRequest.max_z = requestRangeUpdate.Value.Max.z;
}
if (fetchUnits)
{
if (unitListCall != null)
{
UnitList unitList = unitListCall.Execute(blockRequest);
netUnitList.Set(unitList);
}
else if (unitListCallLegacy != null)
{
UnitList unitList = unitListCallLegacy.Execute();
netUnitList.Set(unitList);
}
}
if (fetchWorldMap)
{
if (worldMapCenterCall != null)
{
WorldMap tempWorldMap;
worldMapCenterCall.TryExecute(null, out tempWorldMap);
if (tempWorldMap != null)
{
DFTime = new DFTime(tempWorldMap.cur_year, tempWorldMap.cur_year_tick);
}
if (netWorldMapCenter == null || (tempWorldMap != null &&
(netWorldMapCenter.center_x != tempWorldMap.center_x ||
netWorldMapCenter.center_y != tempWorldMap.center_y)))
{
if (worldMapCall != null)
{
WorldMap worldMap;
worldMapCall.TryExecute(null, out worldMap);
netWorldMap.Set(worldMap);
}
netWorldMapCenter = tempWorldMap;
worldMapMoved.Set();
if (regionMapCall != null)
{
RegionMaps regionMaps;
regionMapCall.TryExecute(null, out regionMaps);
netRegionMaps.Set(regionMaps);
}
nextRegionUpdate = DateTime.Now.AddSeconds(0.2); //add another region map update after this one, to get delayed regions.s
}
}
if (nextRegionUpdate < DateTime.Now)
{
if (regionMapCall != null)
{
RegionMaps regionMaps;
regionMapCall.TryExecute(null, out regionMaps);
netRegionMaps.Set(regionMaps);
}
nextRegionUpdate = DateTime.MaxValue;
}
}
if (pauseCommandCall != null)
{
SingleBool status;
pauseStatusCall.TryExecute(null, out status);
if (status != null)
{
_dfPauseState = status.Value;
}
}
// since enqueueing results can block, we do it after we've unsuspended df
BlockList resultList = null;
if (fetchMap)
{
if (EmbarkMapSize.x > 0 &&
EmbarkMapSize.y > 0 &&
EmbarkMapSize.z > 0 && _needNewBlocks)
{
if (blockListCall != null)
{
//Don't pull more blocks than we have room for in the queue. It blocks things unneccesarily.
blockRequest.blocks_needed = Mathf.Min(blockRequest.blocks_needed, pendingBlocks.Capacity - pendingBlocks.Count - 1);
if (blockRequest.blocks_needed > 0)
{
resultList = blockListCall.Execute(blockRequest);
}
}
}
}
Status stat = null;
if (reportsCall != null)
{
reportsCall.TryExecute(null, out stat);
if (stat != null)
{
netStatus.Set(stat);
}
}
#endregion
//All communication with DF should be before this.
networkClient.ResumeGame();
if (resultList != null)
{
try
{
foreach (MapBlock mapBlock in resultList.map_blocks)
{
pendingBlocks.Enqueue(mapBlock);
}
engravings.Enqueue(resultList.engravings);
}
catch (Exception e)
{
Debug.LogException(e);
}
waves = resultList.ocean_waves;
UpdatedAnyBlocks = true;
}
}
/// <summary>
/// Performs a single update.
/// </summary>
/// <exception cref="System.Exception"></exception>
void PerformSingleUpdate()
{
networkClient.suspend_game();
if (mapResetRequested.Pop())
{
mapResetCall.execute();
}
if (mapInfoCall != null)
{
RemoteFortressReader.MapInfo mapInfo;
mapInfoCall.execute(null, out mapInfo);
if (mapInfo == null)
{
if (netMapInfo != null)
{
lock (mapInfoLock)
{
embarkMapPosition = new DFCoord(-1, -1, -1);
embarkMapSize = new DFCoord(0, 0, 0);
MapDataStore.InitMainMap(embarkMapSize.x * 16, embarkMapSize.y * 16, embarkMapSize.z);
}
}
}
else
{
if ((netMapInfo == null) ||
mapInfo.block_pos_x != netMapInfo.block_pos_x ||
mapInfo.block_pos_y != netMapInfo.block_pos_y ||
mapInfo.block_pos_z != netMapInfo.block_pos_z ||
mapInfo.block_size_x != netMapInfo.block_size_x ||
mapInfo.block_size_y != netMapInfo.block_size_y ||
mapInfo.block_size_z != netMapInfo.block_size_z)
{
lock (mapInfoLock)
{
embarkMapPosition = new DFCoord(mapInfo.block_pos_x, mapInfo.block_pos_y, mapInfo.block_pos_z);
embarkMapSize = new DFCoord(mapInfo.block_size_x, mapInfo.block_size_y, mapInfo.block_size_z);
MapDataStore.InitMainMap(EmbarkMapSize.x * 16, EmbarkMapSize.y * 16, EmbarkMapSize.z);
mapResetCall.execute();
}
}
}
netMapInfo = mapInfo;
}
if (viewInfoCall != null)
{
RemoteFortressReader.ViewInfo viewInfo;
viewInfoCall.execute(null, out viewInfo);
netViewInfo.Set(viewInfo);
}
if (copyScreenCall != null)
{
RemoteFortressReader.ScreenCapture screenCapture;
copyScreenCall.execute(null, out screenCapture);
netScreenCapture.Set(screenCapture);
}
if (unitListCall != null)
{
RemoteFortressReader.UnitList unitList;
unitListCall.execute(null, out unitList);
netUnitList.Set(unitList);
}
if (worldMapCenterCall != null)
{
RemoteFortressReader.WorldMap tempWorldMap;
worldMapCenterCall.execute(null, out tempWorldMap);
if (tempWorldMap != null)
{
DFTime = new DFTime(tempWorldMap.cur_year, tempWorldMap.cur_year_tick);
}
if (netWorldMapCenter == null || (tempWorldMap != null &&
(netWorldMapCenter.center_x != tempWorldMap.center_x ||
netWorldMapCenter.center_y != tempWorldMap.center_y)))
{
if (worldMapCall != null)
{
RemoteFortressReader.WorldMap worldMap;
worldMapCall.execute(null, out worldMap);
netWorldMap.Set(worldMap);
}
netWorldMapCenter = tempWorldMap;
worldMapMoved.Set();
if (regionMapCall != null)
{
RemoteFortressReader.RegionMaps regionMaps;
regionMapCall.execute(null, out regionMaps);
netRegionMaps.Set(regionMaps);
}
nextRegionUpdate = DateTime.Now.AddSeconds(0.2); //add another region map update after this one, to get delayed regions.s
}
}
if (nextRegionUpdate < DateTime.Now)
{
if (regionMapCall != null)
{
RemoteFortressReader.RegionMaps regionMaps;
regionMapCall.execute(null, out regionMaps);
netRegionMaps.Set(regionMaps);
}
nextRegionUpdate = DateTime.MaxValue;
}
if (keyboardEventCall != null)
{
RemoteFortressReader.KeyboardEvent dfEvent;
while (keyPresses.TryDequeue(out dfEvent))
{
keyboardEventCall.execute(dfEvent);
}
}
// since enqueueing results can block, we do it after we've unsuspended df
RemoteFortressReader.BlockList resultList = null;
if (EmbarkMapSize.x > 0 &&
EmbarkMapSize.y > 0 &&
EmbarkMapSize.z > 0)
{
BlockCoord.Range?requestRangeUpdate = requestRegion.Pop();
if (requestRangeUpdate != null)
{
blockRequest.min_x = requestRangeUpdate.Value.Min.x;
blockRequest.min_y = requestRangeUpdate.Value.Min.y;
blockRequest.min_z = requestRangeUpdate.Value.Min.z;
blockRequest.max_x = requestRangeUpdate.Value.Max.x;
blockRequest.max_y = requestRangeUpdate.Value.Max.y;
blockRequest.max_z = requestRangeUpdate.Value.Max.z;
}
if (blockListCall != null)
{
blockListCall.execute(blockRequest, out resultList);
}
}
networkClient.resume_game();
if (resultList != null)
{
foreach (RemoteFortressReader.MapBlock mapBlock in resultList.map_blocks)
{
pendingBlocks.Enqueue(mapBlock);
}
}
}
/// <summary>
/// Performs a single update.
/// </summary>
/// <exception cref="System.Exception"></exception>
void PerformSingleUpdate()
{
//pause df here, so it doesn't try to resume while we're working.
networkClient.suspend_game();
//everything that controls DF.
#region DF Control
if (mapResetRequested.Pop())
{
mapResetCall.execute();
}
if (digCommandCall != null)
{
while (netDigCommands.Count > 0)
{
digCommandCall.execute(netDigCommands.Dequeue());
}
}
if (pauseCommandCall != null)
{
while (pauseCommands.Count > 0)
{
pauseCommandCall.execute(pauseCommands.Dequeue());
}
}
if (keyboardEventCall != null)
{
KeyboardEvent dfEvent;
while (keyPresses.TryDequeue(out dfEvent))
{
keyboardEventCall.execute(dfEvent);
}
}
#endregion
#region DF Read
if (fetchMap)
{
if (mapInfoCall != null)
{
MapInfo mapInfo;
mapInfoCall.execute(null, out mapInfo);
if (mapInfo == null)
{
if (netMapInfo != null)
{
lock (mapInfoLock)
{
embarkMapPosition = new DFCoord(-1, -1, -1);
embarkMapSize = new DFCoord(0, 0, 0);
MapDataStore.InitMainMap(embarkMapSize.x * 16, embarkMapSize.y * 16, embarkMapSize.z);
}
}
}
else
{
if ((netMapInfo == null) ||
mapInfo.block_pos_x != netMapInfo.block_pos_x ||
mapInfo.block_pos_y != netMapInfo.block_pos_y ||
mapInfo.block_pos_z != netMapInfo.block_pos_z ||
mapInfo.block_size_x != netMapInfo.block_size_x ||
mapInfo.block_size_y != netMapInfo.block_size_y ||
mapInfo.block_size_z != netMapInfo.block_size_z)
{
lock (mapInfoLock)
{
embarkMapPosition = new DFCoord(mapInfo.block_pos_x, mapInfo.block_pos_y, mapInfo.block_pos_z);
embarkMapSize = new DFCoord(mapInfo.block_size_x, mapInfo.block_size_y, mapInfo.block_size_z);
MapDataStore.InitMainMap(EmbarkMapSize.x * 16, EmbarkMapSize.y * 16, EmbarkMapSize.z);
mapResetCall.execute();
}
}
}
netMapInfo = mapInfo;
}
if (viewInfoCall != null)
{
ViewInfo viewInfo;
viewInfoCall.execute(null, out viewInfo);
netViewInfo.Set(viewInfo);
}
}
if (fetchScreen)
{
if (copyScreenCall != null)
{
ScreenCapture screenCapture;
copyScreenCall.execute(null, out screenCapture);
netScreenCapture.Set(screenCapture);
}
}
if (fetchUnits)
{
if (unitListCall != null)
{
UnitList unitList;
unitListCall.execute(null, out unitList);
netUnitList.Set(unitList);
}
}
if (fetchWorldMap)
{
if (worldMapCenterCall != null)
{
WorldMap tempWorldMap;
worldMapCenterCall.execute(null, out tempWorldMap);
if (tempWorldMap != null)
{
DFTime = new DFTime(tempWorldMap.cur_year, tempWorldMap.cur_year_tick);
}
if (netWorldMapCenter == null || (tempWorldMap != null &&
(netWorldMapCenter.center_x != tempWorldMap.center_x ||
netWorldMapCenter.center_y != tempWorldMap.center_y)))
{
if (worldMapCall != null)
{
WorldMap worldMap;
worldMapCall.execute(null, out worldMap);
netWorldMap.Set(worldMap);
}
netWorldMapCenter = tempWorldMap;
worldMapMoved.Set();
if (regionMapCall != null)
{
RegionMaps regionMaps;
regionMapCall.execute(null, out regionMaps);
netRegionMaps.Set(regionMaps);
}
nextRegionUpdate = DateTime.Now.AddSeconds(0.2); //add another region map update after this one, to get delayed regions.s
}
}
if (nextRegionUpdate < DateTime.Now)
{
if (regionMapCall != null)
{
RegionMaps regionMaps;
regionMapCall.execute(null, out regionMaps);
netRegionMaps.Set(regionMaps);
}
nextRegionUpdate = DateTime.MaxValue;
}
}
if (pauseCommandCall != null)
{
SingleBool status;
pauseStatusCall.execute(null, out status);
if (status != null)
{
_dfPauseState = status.Value;
}
}
// since enqueueing results can block, we do it after we've unsuspended df
BlockList resultList = null;
if (fetchMap)
{
if (EmbarkMapSize.x > 0 &&
EmbarkMapSize.y > 0 &&
EmbarkMapSize.z > 0 && _needNewBlocks)
{
BlockCoord.Range?requestRangeUpdate = requestRegion.Pop();
if (requestRangeUpdate != null)
{
blockRequest.min_x = requestRangeUpdate.Value.Min.x;
blockRequest.min_y = requestRangeUpdate.Value.Min.y;
blockRequest.min_z = requestRangeUpdate.Value.Min.z;
blockRequest.max_x = requestRangeUpdate.Value.Max.x;
blockRequest.max_y = requestRangeUpdate.Value.Max.y;
blockRequest.max_z = requestRangeUpdate.Value.Max.z;
}
if (blockListCall != null)
{
blockListCall.execute(blockRequest, out resultList);
}
}
}
#endregion
//All communication with DF should be before this.
networkClient.resume_game();
if (resultList != null)
{
foreach (MapBlock mapBlock in resultList.map_blocks)
{
pendingBlocks.Enqueue(mapBlock);
}
}
}
