Fix some issues related to chunk loading

Author: kennyvv

src/Alex/Alex.csproj

@@ -93,6 +93,7 @@
     <ItemGroup>
         <PackageReference Include="CommandLineParser" Version="2.9.0-preview1" />
         <PackageReference Include="ConcurrentHashSet" Version="1.3.0" />
+        <PackageReference Include="ConcurrentObservableCollections" Version="1.1.9" />
         <PackageReference Include="DiscordRichPresence" Version="1.0.175" />
         <PackageReference Include="EasyPipes" Version="1.3.0" />
         <PackageReference Include="FmodAudio" Version="2.2.5" />

src/Alex/Utils/Auth/AuthResponse.cs

@@ -5,6 +5,8 @@ namespace Alex.Utils.Auth
 {
 	public class AuthResponse<TClaims>
 	{
+		[JsonIgnore] public bool Error { get; set; }
+		[JsonIgnore] public int StatusCode { get; set; }
 		[JsonProperty("IssueInstant")] public DateTimeOffset IssueInstant { get; set; }
 
 		[JsonProperty("NotAfter")] public DateTimeOffset NotAfter { get; set; }

src/Alex/Utils/Auth/MojangApi.cs

@@ -231,11 +231,27 @@ private static async Task<MojangAuthResponse> ExchangeLiveForXbox(BedrockTokenPa
 		{
 			HttpClient client = _httpClient;
 			var xblResponse = await _xboxAuth.AuthenticateWithXBL(client, token.AccessToken);
+
+			if (xblResponse.Error)
+			{
+				return new MojangAuthResponse(MojangAuthResult.BadRequest)
+				{
+					ErrorMessage = "Invalid credentials...", StatusCode = (int)xblResponse.StatusCode
+				};
+			}
+			
 			var xblToken = xblResponse.Token;
 			var userHash = xblResponse.DisplayClaims.Xui[0].Uhs;
 
 			var xsts = await _xboxAuth.AuthenticatewithJavaXSTS(client, xblToken);
-
+			if (xsts.Error)
+			{
+				return new MojangAuthResponse(MojangAuthResult.BadRequest)
+				{
+					ErrorMessage = "Invalid credentials...", StatusCode = (int)xsts.StatusCode
+				};
+			}
+			
 			userHash = xsts.DisplayClaims.Xui[0].UserHash;
 			var xstsToken = xsts.Token;
 			var rawLoginResult = await _xboxAuth.AuthenticateWithMinecraft(client, userHash, xstsToken);

src/Alex/Utils/Auth/XboxAuthService.cs

@@ -274,7 +274,12 @@ public async Task<AuthResponse<XuiDisplayClaims<XstsXui>>> AuthenticatewithJavaX
 				using (var response = await client.SendAsync(r, HttpCompletionOption.ResponseContentRead)
 					      .ConfigureAwait(false))
 				{
-					response.EnsureSuccessStatusCode();
+					if (!response.IsSuccessStatusCode)
+						return new AuthResponse<XuiDisplayClaims<XstsXui>>()
+						{
+							Error = true,
+							StatusCode = (int) response.StatusCode
+						};
 
 					var rawResponse = await response.Content.ReadAsStringAsync();
 
@@ -426,7 +431,12 @@ public async Task<AuthResponse<XuiDisplayClaims<Xui>>> AuthenticateWithXBL(HttpC
 				using (var response = await client.SendAsync(r, HttpCompletionOption.ResponseContentRead)
 					      .ConfigureAwait(false))
 				{
-					response.EnsureSuccessStatusCode();
+					if (!response.IsSuccessStatusCode)
+						return new AuthResponse<XuiDisplayClaims<Xui>>()
+						{
+							Error = true,
+							StatusCode = (int) response.StatusCode
+						};
 
 					return JsonConvert.DeserializeObject<AuthResponse<XuiDisplayClaims<Xui>>>(
 						await response.Content.ReadAsStringAsync());

src/Alex/Worlds/ChunkManager.cs

@@ -94,7 +94,8 @@ public class ChunkManager : IDisposable, ITicked
 		private ActionBlock<ChunkUpdateData> _actionBlock;
 		private PriorityBufferBlock<ChunkUpdateData> _priorityBuffer;
 		private List<ChunkCoordinates> _queued = new List<ChunkCoordinates>();
-
+		private object _queuedLock = new object();
+		
 		public bool CalculateSkyLighting { get; set; } = true;
 		public bool CalculateBlockLighting { get; set; } = true;
 
@@ -111,20 +112,9 @@ public ChunkManager(IServiceProvider serviceProvider,
 			Options = serviceProvider.GetRequiredService<IOptionsProvider>().AlexOptions;
 
 			_resourceManager = serviceProvider.GetRequiredService<ResourceManager>();
-			//var stillAtlas =  serviceProvider.GetRequiredService<ResourceManager>().BlockAtlas.GetAtlas();
 
 			//var fogStart = 0;
 			Shaders = new RenderingShaders();
-			//Shaders.SetTextures(stillAtlas);
-			/*FogEnabled = Options.VideoOptions.Fog.Value;
-			FogDistance = Options.VideoOptions.RenderDistance.Value;
-			Options.VideoOptions.Fog.Bind(
-				(old, newValue) =>
-				{
-					FogEnabled = newValue;
-					FogDistance = RenderDistance;
-				});*/
-			//_renderSampler.MaxMipLevel = stillAtlas.LevelCount;
 
 			Chunks = new ConcurrentDictionary<ChunkCoordinates, ChunkColumn>();
 			CancellationToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
@@ -197,7 +187,7 @@ private void BuildActionBlock(int threads)
 			{
 				CancellationToken = CancellationToken.Token,
 				EnsureOrdered = false,
-				MaxDegreeOfParallelism = Math.Max(threads / 3, 1),
+				MaxDegreeOfParallelism = 1,
 				NameFormat = "Chunk Builder: {0}-{1}"
 			};
 
@@ -332,16 +322,31 @@ public void EnsureStarted()
 			_processingThread = task;
 		}
 
+
+		private bool IsQueued(ChunkCoordinates coordinates)
+		{
+			lock (_queuedLock)
+				return _queued.Contains(coordinates);
+		}
+		
+		private void RemoveQueued(ChunkCoordinates coordinates)
+		{
+			lock (_queuedLock)
+			{
+				_queued.Remove(coordinates);
+			}
+		}
+		
 		private void DoUpdate(ChunkUpdateData data)
 		{
 			Interlocked.Increment(ref _threadsRunning);
 
 			try
 			{
-				if (!TryGetChunk(data.Coordinates, out var chunk) || !chunk.Scheduled) return;
-
-				if (!Monitor.TryEnter(chunk.UpdateLock, 0))
+				if (!TryGetChunk(data.Coordinates, out var chunk) || !chunk.Semaphore.Wait(0))
+				{
 					return;
+				}
 
 				Stopwatch timingWatch = Stopwatch.StartNew();
 
@@ -358,24 +363,20 @@ private void DoUpdate(ChunkUpdateData data)
 						chunk.CalculateLighting = false;
 					}
 
-					//using (var ba = new CachedBlockAccess(World))
-					//{
-						if (chunk.UpdateBuffer(World, true))
-						{
-							chunk.Scheduled = false;
-							OnChunkUpdate?.Invoke(this, new ChunkUpdatedEventArgs(chunk, timingWatch.Elapsed));
-						}
-					//}
+					if (chunk.UpdateBuffer(World, true))
+					{
+						OnChunkUpdate?.Invoke(this, new ChunkUpdatedEventArgs(chunk, timingWatch.Elapsed));
+					}
 				}
 				finally
 				{
-					_queued.Remove(data.Coordinates);
 					//chunk.Scheduled = false;
-					Monitor.Exit(chunk.UpdateLock);
+					chunk.Semaphore.Release();
 				}
 			}
 			finally
 			{
+				RemoveQueued(data.Coordinates);
 				Interlocked.Decrement(ref _threadsRunning);
 			}
 		}
@@ -416,7 +417,8 @@ public void AddChunk(ChunkColumn chunk, ChunkCoordinates position, bool doUpdate
 
 		private void OnRemoveChunk(ChunkColumn column, bool dispose)
 		{
-			_queued?.Remove(new ChunkCoordinates(column.X, column.Z));
+			RemoveQueued(new ChunkCoordinates(column.X, column.Z));
+
 			OnChunkRemoved?.Invoke(this, new ChunkRemovedEventArgs(column));
 
 			if (dispose)
@@ -464,30 +466,36 @@ public void ScheduleChunkUpdate(ChunkCoordinates position,
 		{
 			if (!Chunks.TryGetValue(position, out var cc)) return;
 
-			if (cc.Scheduled && !prioritize)
+			if (IsQueued(position) || !Monitor.TryEnter(cc.QueueLock, 0))
 				return;
-
-			cc.Scheduled = true;
-
-			//if (!cc.Neighboring.Contains(source))
-			//	cc.Neighboring.Add(source);
-
-			Priority priority = Priority.Medium;
-
-			if (prioritize)
+			
+			lock (_queuedLock)
 			{
-				priority = Priority.High;
+				if (!_queued.Contains(position))
+				{
+					_queued.Add(position);
+				}
 			}
-			else if ((type & ScheduleType.Border) != 0)
+			
+			try
 			{
-				priority = Priority.Low;
-			}
+				Priority priority = Priority.Medium;
 
-			if (!_queued.Contains(position))
-			{
-				_queued.Add(position);
+				if (prioritize)
+				{
+					priority = Priority.High;
+				}
+				else if ((type & ScheduleType.Border) != 0)
+				{
+					priority = Priority.Low;
+				}
+				
 				_priorityBuffer.Post(new ChunkUpdateData(position, type, source), priority);
 			}
+			finally
+			{
+				Monitor.Exit(cc.QueueLock);
+			}
 		}
 
 		#region Drawing
@@ -688,7 +696,7 @@ public void OnTick()
 
 				if (inView && index + 1 < max)
 				{
-					if (chunk.Value.IsNew && !chunk.Value.Scheduled)
+					if (chunk.Value.IsNew)
 					{
 						ScheduleChunkUpdate(chunk.Key, ScheduleType.Full);
 					}

src/Alex/Worlds/Chunks/ChunkColumn.cs

@@ -34,8 +34,11 @@ public class ChunkColumn
 		//	private readonly int[] _biomeId;
 		private readonly short[] _height = new short[256];
 
-		public object UpdateLock { get; set; } = new object();
+		//public object UpdateLock { get; set; } = new object();
+		public readonly SemaphoreSlim Semaphore = new SemaphoreSlim(1);
+		private readonly SemaphoreSlim DataSemaphore = new SemaphoreSlim(1);
 
+		public object QueueLock = new object();
 		public ConcurrentDictionary<BlockCoordinates, NbtCompound> BlockEntities { get; }
 		//public  NbtCompound[]                                       GetBlockEntities => BlockEntities.ToArray();
 
@@ -54,7 +57,6 @@ private set
 			}
 		}
 
-		private object _dataLock = new object();
 		public WorldSettings WorldSettings { get; }
 		protected readonly int _sectionOffset;
 		private ChunkData _chunkData;
@@ -130,13 +132,12 @@ protected void SetScheduled(int x, int y, int z, bool value)
 		public static float AverageUpdateTime => MovingAverage.Average;
 		public static float MaxUpdateTime => MovingAverage.Maximum;
 		public static float MinUpdateTime => MovingAverage.Minimum;
-		public bool Scheduled { get; set; } = false;
 
 		private static readonly MovingAverage MovingAverage = new MovingAverage();
 
 		public bool UpdateBuffer(IBlockAccess world, bool applyChanges)
 		{
-			if (!Monitor.TryEnter(_dataLock, 0))
+			if (!DataSemaphore.Wait(0))
 				return false;
 
 			Stopwatch time = Stopwatch.StartNew();
@@ -219,7 +220,7 @@ public bool UpdateBuffer(IBlockAccess world, bool applyChanges)
 			}
 			finally
 			{
-				Monitor.Exit(_dataLock);
+				DataSemaphore.Release();
 				time.Stop();
 
 				MovingAverage.ComputeAverage((float)time.Elapsed.TotalMilliseconds);
@@ -608,7 +609,6 @@ public bool RemoveBlockEntity(BlockCoordinates coordinates)
 			return BlockEntities.TryRemove(coordinates, out _);
 		}
 
-		public List<ChunkCoordinates> Neighboring = new List<ChunkCoordinates>();
 		private bool _disposed = false;
 
 		private void Dispose(bool disposing)