Erste Gui Version. Es wird lediglich die Map gezeichnet. Das Backend ist angeschlossen

src/Backend.cs

@@ -2,25 +2,32 @@ using System.Net.Sockets;
 using System.Collections.Generic;
 using WorldOfPeacecraft;
 
-namespace Frontend
+namespace WorldOfPeacecraft
 {
 	public class Backend : IBackend
 	{
+		private Sender Send;
 		private Receiver Rec;
 		private Parser Parse;
 		private TcpClient Client;
 		private Dictionary<int, Dragon> Dragons;
 		private Dictionary<int, Player> Players;
 		private Map Map;
-        private Buffer Buffer;
+        private Buffer SenderBuffer;
+		private IGui Gui;
 
-		public Backend ()
+		public Backend (IGui gui)
 		{
-			Parse = new Parser (Buffer);
-			Client = new TcpClient ("localhost", 9999);
-			Rec = new Receiver (Client, Buffer);
+			Gui = gui;
 			Dragons = new Dictionary<int, Dragon> ();
 			Players = new Dictionary<int, Player> ();
+			Client = new TcpClient ("localhost", 9999);
+			Buffer receiverBuffer = new Buffer(10000);
+			SenderBuffer = new Buffer(100);
+			Parse = new Parser (this, receiverBuffer);
+			Rec = new Receiver (Client, receiverBuffer);
+			Send = new Sender (Client, SenderBuffer);
+			SenderBuffer.AddLine("get:map");
 		}
 
 		public IEnumerable<IPositionable> getDragons ()
@@ -83,8 +90,11 @@ namespace Frontend
 			this.Map = map;
 		}
 
-		public ITile[,] getMap ()
+		public ITile[,] GetMap ()
 		{
+			if (Map == null) {
+				return null;
+			}
 			return Map.GetTiles ();
 		}
 
@@ -95,5 +105,10 @@ namespace Frontend
 		public void sendChat (string message)
 		{
 		}
+
+		public void RefreshGui()
+		{
+			Gui.PerformRefresh();
+		}
 	}
 }

src/Buffer.cs

@@ -1,35 +1,56 @@
-using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Threading;
 
 namespace WorldOfPeacecraft
 {
-    public class Buffer
-    {
-        private Queue<string> RawBuffer = new Queue<string>();
-        private AutoResetEvent BufferFilledEvent = new AutoResetEvent (false);
-        int size;
+	public class Buffer
+	{
+		private Queue<string> Lines = new Queue<string>();
+		private int MaxSize;
+		private AutoResetEvent QueueFullLock = new AutoResetEvent(false);
+		private AutoResetEvent QueueEmptyLock = new AutoResetEvent(false);
 
-        public Buffer(int size)
-        {
-            this.size=size;
-        }
-
-     
-        public void AddToBuffer (string s)
+		public Buffer (int maxSize)
 		{
-            if (RawBuffer.Count >= size){
+			this.MaxSize = maxSize;
+		}
 
-            }
-            else{
-			    lock (RawBuffer) {
-				    RawBuffer.Enqueue (s);
-				    BufferFilledEvent.Set ();
-			    }
-            }
-		
-        }
-    }
+		public void AddLine (string line)
+		{
+			bool waitRequired = false;
+			lock (Lines) {
+				if (Lines.Count >= MaxSize) {
+					waitRequired = true;
+					QueueFullLock.Reset ();
+				}
+			}
+			if (waitRequired) {
+				QueueFullLock.WaitOne ();
+			}
+			lock (Lines) {
+				Lines.Enqueue (line);
+				QueueEmptyLock.Set();
+			}
+		}
+
+		public string NextLine ()
+		{
+			bool waitRequired = false;
+			string line;
+			lock (Lines) {
+				if (Lines.Count == 0) {
+					waitRequired = true;
+					QueueEmptyLock.Reset ();
+				}
+			}
+			if (waitRequired) {
+				QueueEmptyLock.WaitOne ();
+			}
+			lock (Lines) {
+				line = Lines.Dequeue();
+				QueueFullLock.Set ();
+			}
+			return line;
+		}
+	}
 }

src/BufferManuel.cs

@@ -1,56 +0,0 @@
-using System.Collections.Generic;
-using System.Threading;
-
-namespace WorldOfPeacecraft
-{
-	class BufferManuel
-	{
-		private Queue<string> Lines = new Queue<string>();
-		private int MaxSize;
-		private AutoResetEvent QueueFullLock = new AutoResetEvent(false);
-		private AutoResetEvent QueueEmptyLock = new AutoResetEvent(false);
-
-		public BufferManuel (int maxSize)
-		{
-			this.MaxSize = maxSize;
-		}
-
-		public void AddLine (string line)
-		{
-			bool waitRequired = false;
-			lock (Lines) {
-				if (Lines.Count >= MaxSize) {
-					waitRequired = true;
-					QueueFullLock.Reset ();
-				}
-			}
-			if (waitRequired) {
-				QueueFullLock.WaitOne ();
-			}
-			lock (Lines) {
-				Lines.Enqueue (line);
-				QueueEmptyLock.Set();
-			}
-		}
-
-		public string NextLine ()
-		{
-			bool waitRequired = false;
-			string line;
-			lock (Lines) {
-				if (Lines.Count == 0) {
-					waitRequired = true;
-					QueueEmptyLock.Reset ();
-				}
-			}
-			if (waitRequired) {
-				QueueEmptyLock.WaitOne ();
-			}
-			lock (Lines) {
-				line = Lines.Dequeue();
-				QueueFullLock.Set ();
-			}
-			return line;
-		}
-	}
-}

src/Buffer_Wafa.cs

@@ -1,44 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace WorldOfPeacecraft
-{
-	public class Buffer_Wafa
-	{
-		private Queue<string> DotA2 = new Queue<string> ();
-		private int sizelimit;
-
-		public Buffer_Wafa (int limit)
-		{
-			sizelimit = limit;
-		}
-
-		bool isEmpty(){
-			if (DotA2.Count == 0)
-				return true;
-			else
-				return false;
-		}
-
-		bool isFull(){
-			if (DotA2.Count >= sizelimit)
-				return true;
-			else
-				return false;
-		}
-
-		string popMessage(){
-			//TODO
-		}
-
-		void enqueueMessage (string servermessage){
-            bool varIsFull = isFull();
-			if (varIsFull == false) {
-				DotA2.Enqueue (servermessage);
-			} else {
-				//this is else
-			}
-		}
-	}
-}
-

src/Entity.cs

@@ -32,22 +32,22 @@ namespace WorldOfPeacecraft
 			return Id;
 		}
 
-		public void SetPosX (int x)
+		public void SetX (int x)
 		{
 			this.Coord.X = x;
 		}
 
-		public int getXPosition ()
+		public int GetX ()
 		{
 			return Coord.X;
 		}
 
-		public void SetPosY (int y)
+		public void SetY (int y)
 		{
 			this.Coord.Y = y;
 		}
 
-		public int getYPosition ()
+		public int GetY ()
 		{
 			return Coord.Y;
 		}

src/Gui/Gui.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Drawing;
+using System.Windows.Forms;
+using System.Runtime.InteropServices;
+
+namespace WorldOfPeacecraft
+{
+	class Gui : Form, IGui
+	{
+		private const int tileSize = 16;
+		private const int entitySize = 10;
+		private IBackend Backend;
+
+		private Panel Board = new Panel();
+
+		public Gui ()
+		{
+			AllocConsole();
+			InitializeComponents();
+		}
+
+		public void SetBackend (IBackend backend)
+		{
+			Backend = backend;
+		}
+
+		public void InitializeComponents ()
+		{
+			this.SuspendLayout();
+			this.Size = new Size(400, 400);
+			Board.Location = new Point(0,0);
+			Board.Size = new Size(400, 400);
+			Board.Paint += DoPaint;
+			this.DoubleBuffered = true;
+			this.MaximizeBox = false;
+            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
+			this.Name = "WorldOfPeacecraft";
+            this.ShowIcon = false;
+
+			this.Controls.Add(Board);
+			this.ResumeLayout();
+            this.PerformLayout();
+		}
+
+		public void DoPaint (object source, PaintEventArgs args)
+		{
+			BufferedGraphics buffer = BufferedGraphicsManager.Current.Allocate (Board.CreateGraphics (), Board.DisplayRectangle);
+			Graphics g = buffer.Graphics;
+			PaintMap(g);
+			buffer.Render();
+		}
+
+		public void PaintMap (Graphics g)
+		{
+			ITile[,] Map = Backend.GetMap ();
+			if (Map != null) {
+				for (int y = 0; y < Map.GetLength(1); y++) {
+					for (int x = 0; x < Map.GetLength(0); x++) {
+						PaintTile (g, Map [x, y], x, y);
+					}
+				}
+			}
+			else {
+				g.FillRectangle(new SolidBrush(Color.White), Board.DisplayRectangle);
+			}
+		}
+
+		public void PaintTile (Graphics g, ITile tile, int x, int y)
+		{
+			int posx = x * tileSize;
+			int posy = y * tileSize;
+			Color color;
+			if (tile.IsForest ()) {
+				color = Color.Green;
+			} // Stupid parenthesis
+			else if (tile.IsHuntable ()) {
+				color = Color.BurlyWood;
+			} else if (tile.IsWalkable ()) {
+				color = Color.Yellow;
+			} else if (tile.IsWall ()) {
+				color = Color.DarkGray;
+			} else if (tile.IsWater ()) {
+				color = Color.Blue;
+			} else {
+				color = Color.Black;
+			}
+			g.FillRectangle(new SolidBrush(color), posx, posy, tileSize, tileSize);
+		}
+
+		public void PerformRefresh ()
+		{
+			ITile[,] map = Backend.GetMap();
+			int mapWidth = (map.GetLength(0)) * tileSize;
+			int mapHeight = (map.GetLength(1)) * tileSize;
+			this.SuspendLayout();
+			this.ClientSize = new Size(mapWidth, mapHeight);
+			Board.Size = new Size(mapWidth, mapHeight);
+			this.ResumeLayout();
+			this.PerformLayout();
+			this.Refresh();
+		}
+
+		[DllImport("kernel32.dll", SetLastError = true)]
+		[return: MarshalAs(UnmanagedType.Bool)]
+		static extern bool AllocConsole();
+	}
+}

src/Gui/IBackend.cs

@@ -0,0 +1,8 @@
+
+namespace WorldOfPeacecraft
+{
+	public interface IBackend
+	{
+		ITile[,] GetMap();
+	}
+}

src/Gui/IGui.cs

@@ -0,0 +1,8 @@
+namespace WorldOfPeacecraft
+{
+	public interface IGui
+	{
+		void PerformRefresh();
+		void SetBackend(IBackend backend);
+	}
+}

src/Gui/IPositionable.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace WorldOfPeacecraft
+{
+    /// <summary>
+    /// Interface your positionable objects should implement. Such as the dragons and players.
+    /// This enables the frontend to determine the current position of said objects to render them at the correct space.
+    /// </summary>
+    public interface IPositionable
+    {
+        /// <summary>
+        /// Getter for the x-position
+        /// </summary>
+        /// <returns>the x-position</returns>
+        int GetX();
+        /// <summary>
+        /// Getter for the y-position
+        /// </summary>
+        /// <returns>the y-position</returns>
+        int GetY();
+    }
+}

src/Gui/ITile.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace WorldOfPeacecraft
+{
+    public interface ITile : IPositionable
+    {
+        bool IsWalkable();
+        bool IsWall();
+        bool IsForest();
+        bool IsHuntable();
+        bool IsWater();
+    }
+}

src/Gui/Program.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Windows.Forms;
+
+namespace WorldOfPeacecraft
+{
+	public class Program
+	{
+		static void Main()
+		{
+			Application.EnableVisualStyles();
+			Application.SetCompatibleTextRenderingDefault(false);
+
+			Gui gui = new Gui();
+			Backend backend = new Backend(gui);
+			gui.SetBackend(backend);
+			Application.Run (gui);
+		}
+	}
+}
+

src/Map.cs

@@ -13,8 +13,8 @@ namespace WorldOfPeacecraft
 
 		public void SetTile (Tile t)
 		{
-			int x = t.getX ();
-			int y = t.getY ();
+			int x = t.GetX ();
+			int y = t.GetY ();
 			map [x, y] = t;
 		}
 

src/Parser.cs

@@ -49,47 +49,31 @@ namespace WorldOfPeacecraft
 		public const string MessPlayers = "players";
 		public const string MessDragon = "dragon";
 		public const string MessMapcell = "cell";
-		private Buffer MonsterBuffer;
+		private Buffer InputBuffer;
 		private Thread ParserThread;
 		private LinkedList<string> Message;
 		private Regex LastLineRegex;
-		private Backend backend;
+		private Backend Backend;
 
-		public Parser (Buffer b)
+		public Parser (Backend backend, Buffer buffer)
 		{
-            MonsterBuffer = b;
-			ParserThread = new Thread (new ThreadStart (this.RunParser));
-            ParserThread.Start();
+            InputBuffer = buffer;
+			Backend = backend;
 			Message = new LinkedList<string> ();
 			LastLineRegex = new Regex ("^end:[0-9]+$");
+			ParserThread = new Thread (new ThreadStart (this.RunParser));
+            ParserThread.Start();
 		}
 
 		private void RunParser ()
-        {/*
+		{
 			while (true) {
-				bool waitRequired = false;
-				lock (MonsterBuffer) {
-					if (MonsterBuffer.Count == 0) {
-						waitRequired = true;
-						BufferFilledEvent.Reset ();
-					}
-				}
-				if (waitRequired) {
-					BufferFilledEvent.WaitOne ();
-				}
-				lock (Buffer) {
-					Message.AddLast (Buffer.Dequeue ());
-				}
+				Message.AddLast (InputBuffer.NextLine ());
 				if (IsCompletePackage ()) {
 					Parse ();
 				}
-			}*/
+			}
 		}
-        
-        public Player getDummyPlayer()
-        {
-            return DummyPlayer;
-        }
 
 		private void Parse ()
 		{
@@ -188,11 +172,11 @@ namespace WorldOfPeacecraft
 			switch (block.GetName ()) {
 			case MessPlayer:
 				Player player = MapPlayer (block);
-				backend.removePlayer (player);
+				Backend.removePlayer (player);
 				break;
 			case MessDragon:
 				Dragon dragon = MapDragon (block);
-				backend.removeDragon (dragon);
+				Backend.removeDragon (dragon);
 				break;
 			default:
 				ThrowUnknownBlockException(deleteBlock, block);
@@ -215,7 +199,8 @@ namespace WorldOfPeacecraft
 			foreach (Block cell in cellsBlock.GetBlocks()) {
 				map.SetTile(MapMapcell(cell));
 			}
-			backend.SetMap(map);
+			Backend.SetMap(map);
+			Backend.RefreshGui();
 		}
 
 		private void ProcessMessage (Block mesBlock)
@@ -286,7 +271,6 @@ namespace WorldOfPeacecraft
                 break;
 			default:
 				throw new ParsingException("Invalid type"); // TODO Better message
-				break;
             }
             bool accepted = challengeBlock.GetBoolValue("accepted");
             Challenge c = new Challenge(id, type, accepted);
@@ -295,12 +279,12 @@ namespace WorldOfPeacecraft
 
 		private void ProcessPlayer (Block playerBlock)
 		{
-			backend.SetPlayer(MapPlayer(playerBlock));
+			Backend.SetPlayer(MapPlayer(playerBlock));
 		}
 		
 		private void ProcessMapcell (Block mapcellBlock)
 		{
-			backend.getMapObject().SetTile(MapMapcell(mapcellBlock));
+			Backend.getMapObject().SetTile(MapMapcell(mapcellBlock));
 		}
 
 		private void ProcessYourid (Block yourIdBlock)
@@ -329,15 +313,15 @@ namespace WorldOfPeacecraft
 
 		private void ProcessEntities (Block entitiesBlock)
 		{
-			backend.clearDragons ();
-			backend.clearPlayers ();
+			Backend.clearDragons ();
+			Backend.clearPlayers ();
 			foreach (Block entityBlock in entitiesBlock.GetBlocks ()) {
 				switch (entityBlock.GetName()) {
 				case MessPlayer:
-					backend.SetPlayer(MapPlayer(entityBlock));
+					Backend.SetPlayer(MapPlayer(entityBlock));
 					break;
 				case MessDragon:
-					backend.SetDragon(MapDragon(entityBlock));
+					Backend.SetDragon(MapDragon(entityBlock));
 					break;
 				default:
 					ThrowUnknownBlockException(entitiesBlock, entityBlock);
@@ -348,15 +332,15 @@ namespace WorldOfPeacecraft
 
 		private void ProcessPlayers (Block playersBlock)
 		{
-			backend.clearPlayers ();
+			Backend.clearPlayers ();
 			foreach (Block playerBlock in playersBlock.GetBlocks ()) {
-				backend.SetPlayer(MapPlayer(playerBlock));
+				Backend.SetPlayer(MapPlayer(playerBlock));
 			}
 		}
 
 		private void ProcessDragon (Block dragonBlock)
 		{
-			backend.SetDragon(MapDragon(dragonBlock));
+			Backend.SetDragon(MapDragon(dragonBlock));
 		}
 
 		private Dragon MapDragon (Block dragonBlock)

src/Receiver.cs

@@ -9,13 +9,13 @@ namespace WorldOfPeacecraft
 	{
 		private TcpClient Client;
 		private StreamReader Reader;
-		private Buffer KillerBuffer;
+		private Buffer ReceiverBuffer;
 		private Thread ReceiverThread;
 
 		public Receiver (TcpClient client, Buffer buffer)
 		{
 			this.Client = client;
-			this.KillerBuffer = buffer;
+			this.ReceiverBuffer = buffer;
 			ReceiverThread = new Thread(new ThreadStart(this.doReceive));
 			ReceiverThread.Start();
 		}
@@ -29,7 +29,7 @@ namespace WorldOfPeacecraft
 		{
 			this.Reader = new StreamReader (Client.GetStream ());
 			while (true) {
-				KillerBuffer.AddToBuffer(Receive());
+				ReceiverBuffer.AddLine(Receive());
 			}
 		}
 

src/Sender.cs

@@ -2,16 +2,22 @@ using System;
 using System.IO;
 using System.Net.Sockets;
 using System.Text;
+using System.Threading;
 
 namespace WorldOfPeacecraft
 {
 	public class Sender
 	{
 		private TcpClient Client;
+		private Buffer Buffer;
+		private Thread SenderThread;
 
-		public Sender (TcpClient client)
+		public Sender (TcpClient client, Buffer buffer)
 		{
 			this.Client = client;
+			this.Buffer = buffer;
+			this.SenderThread = new Thread(new ThreadStart(this.threadStart));
+			SenderThread.Start();
 		}
 
 		public void Send (String message)
@@ -20,5 +26,17 @@ namespace WorldOfPeacecraft
 			writer.WriteLine (message);
 			writer.Flush ();
 		}
+
+		private void threadStart ()
+		{
+			while (true) {
+				Send (Buffer.NextLine());
+			}
+		}
+
+		public void stop()
+		{
+			SenderThread.Abort();
+		}
 	}
 }

src/Tile.cs

@@ -5,115 +5,104 @@ namespace WorldOfPeacecraft
 {
 	public class Tile : ITile
 	{
-		public int x;
-		public int y;
-		public Entity entity;
-		public bool walkable;
-        public bool wall;
-		public bool forest;
-		public bool huntable;
-		public bool water;
+		public int X;
+		public int Y;
+		public Entity Entity;
+		public bool Walkable;
+        public bool Wall;
+		public bool Forest;
+		public bool Huntable;
+		public bool Water;
 
 		public Tile (int posX, int posY, bool walkable, bool wall, bool forest, bool huntable, bool water)
 		{
-			this.setX (posX);
-			this.setY (posY);
-			this.setWalkable (walkable);
-            this.setWall(wall);
-			this.setForest (forest);
-			this.setHuntable (huntable);
-			this.setWater (water);
+			this.SetX (posX);
+			this.SetY (posY);
+			this.SetWalkable (walkable);
+            this.SetWall(wall);
+			this.SetForest (forest);
+			this.SetHuntable (huntable);
+			this.SetWater (water);
 		}
 
-		public void setX (int x)
+		public void SetX (int x)
 		{
-			this.x = x;
+			this.X = x;
 		}
 
-		public int getX ()
+		public int GetX ()
 		{
-			return x;
+			return X;
 		}
 
-		public int getXPosition ()
+		public void SetY (int y)
 		{
-			return x;
+			this.Y = y;
 		}
 
-		public void setY (int y)
+		public int GetY ()
 		{
-			this.y = y;
+			return Y;
 		}
 
-		public int getY ()
+		public void SetEntity (Entity entity)
 		{
-			return y;
+			this.Entity = entity;
 		}
 
-		public int getYPosition ()
+		public Entity GetEntity ()
 		{
-			return y;
+			return Entity;
 		}
 
-		public void setEntity (Entity entity)
+		public void SetWalkable (bool walkable)
 		{
-			this.entity = entity;
+			this.Walkable = walkable;
 		}
 
-		public Entity getEntity ()
+		public bool IsWalkable ()
 		{
-			return entity;
+			return Walkable;
 		}
 
-		public void setWalkable (bool walkable)
-		{
-			this.walkable = walkable;
-		}
-
-		public bool isWalkable ()
-		{
-			return walkable;
-		}
-
-        public void setWall(bool wall)
+        public void SetWall(bool wall)
         {
-            this.wall = wall;
+            this.Wall = wall;
         }
 
-        public bool isWall()
+        public bool IsWall()
         {
-            return wall;
+            return Wall;
         }
 
-
-		public void setForest (bool forest)
+		public void SetForest (bool forest)
 		{
-			this.forest = forest;
+			this.Forest = forest;
 		}
 
-		public bool isForest ()
+		public bool IsForest ()
 		{
-			return forest;
+			return Forest;
 		}
 
-		public void setHuntable (bool huntable)
+		public void SetHuntable (bool huntable)
 		{
-			this.huntable = huntable;
+			this.Huntable = huntable;
 		}
 
-		public bool isHuntable ()
+		public bool IsHuntable ()
 		{
-			return huntable;
+			return Huntable;
 		}
 
-		public void setWater (bool water)
+		public void SetWater (bool water)
 		{
-			this.water = water;
+			this.Water = water;
 		}
 
-		public bool isWater ()
+		public bool IsWater ()
 		{
-			return water;
+			return Water;
 		}
 	}
 }