Zugriffe auf die Datenstrukturen des Backends werden jetzt über locks

synchronisiert.

src/Gui/Gui.cs

@@ -52,7 +52,9 @@ namespace WorldOfPeacecraft
 		{
 			BufferedGraphics buffer = BufferedGraphicsManager.Current.Allocate (Board.CreateGraphics (), Board.DisplayRectangle);
 			Graphics g = buffer.Graphics;
+			lock (Backend) {
 				PaintMap (g);
+			}
 			buffer.Render();
 		}
 

src/Parser.cs

@@ -172,11 +172,15 @@ namespace WorldOfPeacecraft
 			switch (block.GetName ()) {
 			case MessPlayer:
 				Player player = MapPlayer (block);
+				lock (Backend) {
 					Backend.removePlayer (player);
+				}
 				break;
 			case MessDragon:
 				Dragon dragon = MapDragon (block);
+				lock (Backend) {
 					Backend.removeDragon (dragon);
+				}
 				break;
 			default:
 				ThrowUnknownBlockException(deleteBlock, block);
@@ -199,7 +203,9 @@ namespace WorldOfPeacecraft
 			foreach (Block cell in cellsBlock.GetBlocks()) {
 				map.SetTile(MapMapcell(cell));
 			}
+			lock (Backend) {
 				Backend.SetMap (map);
+			}
 			Backend.RefreshGui();
 		}
 
@@ -279,12 +285,17 @@ namespace WorldOfPeacecraft
 
 		private void ProcessPlayer (Block playerBlock)
 		{
+			lock (Backend) {
 				Backend.SetPlayer (MapPlayer (playerBlock));
 			}
+		}
 		
 		private void ProcessMapcell (Block mapcellBlock)
 		{
-			Backend.getMapObject().SetTile(MapMapcell(mapcellBlock));
+			Tile tile = MapMapcell (mapcellBlock);
+			lock (Backend) {
+				 Backend.getMapObject ().SetTile (tile);
+			}
 		}
 
 		private void ProcessYourid (Block yourIdBlock)
@@ -313,12 +324,16 @@ namespace WorldOfPeacecraft
 
 		private void ProcessEntities (Block entitiesBlock)
 		{
+			// This lock can be placed more efficiently. Does it make sense?
+			lock (Backend) {
 				Backend.clearDragons ();
 				Backend.clearPlayers ();
 				foreach (Block entityBlock in entitiesBlock.GetBlocks ()) {
 					switch (entityBlock.GetName ()) {
 					case MessPlayer:
+						lock (Backend) {
 							Backend.SetPlayer (MapPlayer (entityBlock));
+						}
 						break;
 					case MessDragon:
 						Backend.SetDragon (MapDragon (entityBlock));
@@ -328,19 +343,27 @@ namespace WorldOfPeacecraft
 						break;
 					}
 				}
+				Backend.RefreshGui();
+			}
 		}
 
 		private void ProcessPlayers (Block playersBlock)
 		{
+			// This lock can be placed more efficiently. Does it make sense?
+			lock (Backend) {
 				Backend.clearPlayers ();
 				foreach (Block playerBlock in playersBlock.GetBlocks ()) {
 					Backend.SetPlayer (MapPlayer (playerBlock));
 				}
 			}
+		}
 
 		private void ProcessDragon (Block dragonBlock)
 		{
-			Backend.SetDragon(MapDragon(dragonBlock));
+			Dragon dragon = MapDragon (dragonBlock);
+			lock (Backend) {
+				Backend.SetDragon (dragon);
+			}
 		}
 
 		private Dragon MapDragon (Block dragonBlock)