diff --git a/Connector/Connector.v11.suo b/Connector/Connector.v11.suo
new file mode 100644
index 0000000..c344e47
Binary files /dev/null and b/Connector/Connector.v11.suo differ
diff --git a/Connector/Connector/Program.cs b/Connector/Connector/Program.cs
new file mode 100644
index 0000000..b89be48
--- /dev/null
+++ b/Connector/Connector/Program.cs
@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Connector
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            
+        }
+    }
+}
diff --git a/DefaultGui/DefaultGui/Backend.cs b/DefaultGui/DefaultGui/Backend.cs
new file mode 100644
index 0000000..7a78acb
--- /dev/null
+++ b/DefaultGui/DefaultGui/Backend.cs
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DefaultGui
+{
+    /// <summary>
+    /// All classes in the test-directory are just classes to illustrate the concept of the frontend and its interfaces.
+    /// They are undocumented and not very well written and are using dummy-data with no connection to the actual server.
+    /// On purpose. Because you should come up with your own implementation. :)
+    /// </summary>
+    public class Backend : IBackend
+    {
+        public void sendCommand(string command)
+        {
+            Console.WriteLine("received command " + command);
+        }
+
+        public void sendChat(string message)
+        {
+            Console.WriteLine("received chatmessage " + message);
+        }
+
+        public List<IPositionable> getDragons() {
+            List<IPositionable> dragons = new List<IPositionable>();
+            dragons.Add(new Entity(0,1));
+            return dragons;
+
+        }
+        public List<IPositionable> getPlayers() {
+            List<IPositionable> players = new List<IPositionable>();
+            players.Add(new Entity(1, 1));
+            return players;
+        }
+
+        public ITile[][] getMap()
+        {
+            int size = 10;
+            // init
+            ITile[][] map = new ITile[size][];
+            for (int i = 0; i < size; i++)
+            {
+                map[i] = new ITile[size];
+            }
+            Random r = new Random();
+            for (int x = 0; x < size; x++)
+            {
+                for (int y = 0; y < size; y++)
+                {
+                    List<MapCellAttribute> attr = new List<MapCellAttribute>();
+                    switch (r.Next(0, 5))
+                    {
+                        case 0:
+                            attr.Add(MapCellAttribute.WATER);
+                            break;
+                        case 1:
+                            attr.Add(MapCellAttribute.HUNTABLE);
+                            attr.Add(MapCellAttribute.FOREST);
+                            break;
+                        case 2:
+                            attr.Add(MapCellAttribute.FOREST);
+                            break;
+                        case 3:
+                            attr.Add(MapCellAttribute.UNWALKABLE);
+                            break;
+                        case 4:
+                            break;
+
+                    }
+                    map[x][y] = new MapCell(x, y, attr);
+                }
+            }
+            return map;
+        }
+
+    }
+}
diff --git a/DefaultGui/DefaultGui/DefaultGui.Designer.cs b/DefaultGui/DefaultGui/DefaultGui.Designer.cs
new file mode 100644
index 0000000..9ff6316
--- /dev/null
+++ b/DefaultGui/DefaultGui/DefaultGui.Designer.cs
@@ -0,0 +1,39 @@
+namespace DefaultGui
+{
+    partial class DefaultGui
+    {
+        /// <summary>
+        /// Erforderliche Designervariable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        /// Verwendete Ressourcen bereinigen.
+        /// </summary>
+        /// <param name="disposing">True, wenn verwaltete Ressourcen gelöscht werden sollen; andernfalls False.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && (components != null))
+            {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Vom Windows Form-Designer generierter Code
+
+        /// <summary>
+        /// Erforderliche Methode für die Designerunterstützung.
+        /// Der Inhalt der Methode darf nicht mit dem Code-Editor geändert werden.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            this.components = new System.ComponentModel.Container();
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.Text = "Form1";
+        }
+
+        #endregion
+    }
+}
+
diff --git a/DefaultGui/DefaultGui/DefaultGui.cs b/DefaultGui/DefaultGui/DefaultGui.cs
new file mode 100644
index 0000000..e920350
--- /dev/null
+++ b/DefaultGui/DefaultGui/DefaultGui.cs
@@ -0,0 +1,278 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Data;
+using System.Drawing;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+using System.Runtime.InteropServices;
+using System.Diagnostics;
+
+namespace DefaultGui
+{
+    /// <summary>
+    /// This is a very, very basic GUI. It communicates with any IBackend, takes the map and existing entities and renders them in a generic fashion.
+    /// The space will be devided evenly among the ITiles of a map. That means: bigger maps will result in very tiny cells on the GUI.
+    /// No scrolling or any fancy mechanisms.
+    /// Entities will also be displayed in a generic way: players are rendered in yellow, dragons are red. No IDs, names or whatsoever.
+    /// It also offers basic functionality to communicate with the backend to input commands via the chat. So you can do some testing by manually entering commands like "/get:map".
+    /// The GUI also consists of a chat-window, featuring incoming chat-messages and a input-box, to send messages to the IBackend (which have to be handled there!).
+    /// Pressing ENTER sends the text in the input-box and also switches between chat-mode and walk-mode. In walk-mode, pressing WASD causes the frontend to send move-commands to the IBackend.
+    /// As you can see, this is just rudimentary functionality and rendering and you might wish (and are invited) to extend the class, modify the existing sourcecode or even write your very own implementation to have a more appealing GUI that fits your needs.
+    /// 
+    /// To get this to work, you will have to let your backend implemented the provided IBackend-interface (and of course the other provided interfaces where needed). Then 
+    /// </summary>
+    public partial class DefaultGui : Form
+    {
+        private IBackend backend;
+        public DefaultGui(IBackend backend)
+            : base()
+        {
+            if (backend == null)
+            {
+                throw new ArgumentNullException("invalid value for 'backend': null");
+            }
+            this.backend = backend;
+            InitializeComponent();
+            // we usually don't have a console in a form-project. This enables us to see debug-output anyway
+            AllocConsole();
+            this.board.Paint += board_PaintMap;
+            this.board.Paint += board_PaintEntities;
+            this.chatInput.KeyPress += chat_KeyPress;
+            this.board.KeyPress += board_KeyPress;
+        }
+
+        /// <summary>
+        /// Handles keypresses the chatInput-field receives.
+        /// Having ENTER pressed, causes the field to be emptied and have the trimmed text in the field sent to the backend.
+        /// If the input starts with "/", it will be handled as command (like ask:mv:up and such).
+        /// All other messages will be treated as chat-messages and have to be wrapped by the backend as such.
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        private void chat_KeyPress(object sender, System.Windows.Forms.KeyPressEventArgs e)
+        {
+            if (e.KeyChar == (char)Keys.Enter)
+            {
+                string input = this.chatInput.Text.Trim();
+                this.chatInput.Text = "";
+                // ignore empty input
+                if (input != "")
+                {
+                    if (input.StartsWith("/"))
+                    {
+                        input = input.Substring(1, input.Length - 1);
+                        this.backend.sendCommand(input);
+                    }
+                    else
+                    {
+                        this.backend.sendChat(input);
+                    }
+                }
+                this.board.Focus();
+            }
+
+        }
+
+        /// <summary>
+        /// Handles keypresses when the board is focused. This is whenever the chatinput is NOT focused.
+        /// Will handle WASD as triggers for the movement.
+        /// A: left
+        /// W: up
+        /// S: down
+        /// D: right
+        /// Pressing ENTER causes the chatinput to be focused again.
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        private void board_KeyPress(object sender, System.Windows.Forms.KeyPressEventArgs e)
+        {
+            // fall-through-cases for capital letters
+            switch (e.KeyChar)
+            {
+                case (char)Keys.Enter:
+                    this.chatInput.Focus();
+                    break;
+                case 'a':
+                case 'A':
+                    this.backend.sendCommand("ask:mv:lft");
+                    break;
+                case 'd':
+                case 'D':
+                    this.backend.sendCommand("ask:mv:rgt");
+                    break;
+                case 'w':
+                case 'W':
+                    this.backend.sendCommand("ask:mv:up");
+                    break;
+                case 's':
+                case 'S':
+                    this.backend.sendCommand("ask:mv:dwn");
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Handler to paint the tiles in the map
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        private void board_PaintMap(object sender, System.Windows.Forms.PaintEventArgs e)
+        {
+            Size tileSize = this.getTileSize();
+            ITile[][] cells = this.backend.getMap();
+            // validity checked beforehand in getTileSize
+            Debug.Assert(cells != null);
+            BufferedGraphics buffer = BufferedGraphicsManager.Current.Allocate(this.board.CreateGraphics(), this.board.DisplayRectangle);
+            Graphics g = this.CreateGraphics();
+            for (int x = 0; x < cells.Length; x++)
+            {
+                for (int y = 0; y < cells[x].Length; y++)
+                {
+                    this.drawMapTile(buffer.Graphics, cells[x][y], x * tileSize.Width, y * tileSize.Height, tileSize.Width, tileSize.Height);
+                }
+            }
+            buffer.Render();
+        }
+
+        /// <summary>
+        /// Handler to paint all entities Dragons first, then the Players
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        private void board_PaintEntities(object sender, System.Windows.Forms.PaintEventArgs e)
+        {
+            List<IPositionable> dragons = this.backend.getDragons();
+            foreach (IPositionable dragon in dragons)
+            {
+                this.drawDragon(e.Graphics, dragon);
+            }
+            List<IPositionable> players = this.backend.getPlayers();
+            foreach (IPositionable player in players)
+            {
+                this.drawPlayer(e.Graphics, player);
+            }
+        }
+
+        /// <summary>
+        /// Draws a tile of the map on a graphics object.
+        /// By default, it will draw a rectangle (colour will be dependent of the attributes of the tile).
+        /// WATER: blue
+        /// FOREST: dark green
+        /// HUNTABLE: light green
+        /// UNWALKABLE: grey
+        /// else: peach
+        /// It will have a black 1px border.
+        /// </summary>
+        /// <param name="g">the graphics-object to draw on</param>
+        /// <param name="tile">the tile-object that implements ITile</param>
+        /// <param name="absX">absolute pixel x-position of the upper left corner of the tile, relative to the upper left corner of the graphics-object</param>
+        /// <param name="absY">absolute pixel y-position of the upper left corner of the tile, relative to the upper left corner of the graphics-object</param>
+        /// <param name="width">width of the tile in pixels</param>
+        /// <param name="height">height of the tile in pixels</param>
+        protected void drawMapTile(Graphics g, ITile tile, int absX, int absY, int width, int height)
+        {
+            Color colour = Color.BurlyWood;
+            if (tile.isForest())
+            {
+                if (tile.isHuntable())
+                {
+                    colour = Color.YellowGreen;
+                }
+                else
+                {
+                    colour = Color.Green;
+                }
+            }
+            else if (tile.isWater())
+            {
+                colour = Color.Blue;
+            }
+            else if (!tile.isWalkable())
+            {
+                colour = Color.DimGray;
+            }
+            g.FillRectangle(new SolidBrush(colour), absX, absY, width, height);
+            g.DrawRectangle(new Pen(new SolidBrush(Color.Black)), new Rectangle(absX, absY, width, height));
+        }
+
+        /// <summary>
+        /// Draws a player on the graphics.
+        /// By default, players will be represented by a centered dark-yellow rectangle that takes up half of the cells size.
+        /// </summary>
+        /// <param name="g">the graphics-object to draw on</param>
+        /// <param name="player">the player to draw</param>
+        protected void drawPlayer(Graphics g, IPositionable player)
+        {
+            Size tileSize = this.getTileSize();
+            g.FillRectangle(new SolidBrush(Color.DarkGoldenrod),
+                player.getXPosition() * tileSize.Width + tileSize.Width / 2 - tileSize.Width / 4,
+                player.getYPosition() * tileSize.Height + tileSize.Height / 2 - tileSize.Height / 4,
+                tileSize.Width / 2,
+                tileSize.Height / 2);
+        }
+
+        /// <summary>
+        /// Draws a dragon on the graphics.
+        /// By default, dragons will be represented by a centered red rectangle that takes up half of the cells size.
+        /// </summary>
+        /// <param name="g">the graphics-object to draw on</param>
+        /// <param name="dragon">the dragon to draw</param>
+        protected void drawDragon(Graphics g, IPositionable dragon)
+        {
+            Size tileSize = this.getTileSize();
+            g.FillRectangle(new SolidBrush(Color.DarkRed),
+                dragon.getXPosition() * tileSize.Width + tileSize.Width / 2 - tileSize.Width / 4,
+                dragon.getYPosition() * tileSize.Height + tileSize.Height / 2 - tileSize.Height / 4,
+                tileSize.Width / 2,
+                tileSize.Height / 2);
+        }
+
+        /// <summary>
+        /// Devides the space of the board-panel equally among the tiles of the map.
+        /// For intance, if the board is 100px wide and the map consists of 5 cells in y-direction
+        /// each tile will have a width of 100px/5 = 20px. Same for the height.
+        /// </summary>
+        /// <returns>the size of one tile to fit the whole map on the board</returns>
+        protected Size getTileSize()
+        {
+            IPositionable[][] cells = this.backend.getMap();
+            if (cells == null)
+            {
+                throw new ArgumentNullException("backend returned null as map");
+            }
+            if (cells.Length == 0)
+            {
+                throw new IndexOutOfRangeException("outer dimension of the retrieved map has length 0");
+            }
+            if (cells[0].Length == 0)
+            {
+                throw new IndexOutOfRangeException("inner dimension of the retrieved map has length 0");
+            }
+            int cellWidth = this.board.Size.Width / cells.Length;
+            int cellHeight = this.board.Size.Height / cells[0].Length; 
+            return new Size(cellWidth, cellHeight);
+        }
+
+        /// <summary>
+        /// Appends a chat-message to the chat-window as a new line. Can be called from the backend or other participants to display incoming chat-messages.
+        /// Messages will always be displays in the fasion of:
+        /// sender: message
+        /// </summary>
+        /// <param name="sender">the source of the message</param>
+        /// <param name="message">the message itself</param>
+        public void appendChatMessage(string sender, string message)
+        {
+            this.chatWindow.AppendText(sender + ": " + message + "\r\n");
+        }
+
+
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        static extern bool AllocConsole();
+
+    }
+}
diff --git a/DefaultGui/DefaultGui/Entity.cs b/DefaultGui/DefaultGui/Entity.cs
new file mode 100644
index 0000000..20fe464
--- /dev/null
+++ b/DefaultGui/DefaultGui/Entity.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DefaultGui
+{
+    public class Entity : IPositionable
+    {
+        int x, y;
+        public Entity(int x, int y)
+        {
+            this.x = x;
+            this.y = y;
+        }
+
+        public int getXPosition()
+        {
+            return this.x;
+        }
+
+        public int getYPosition()
+        {
+            return this.y;
+        }
+    }
+}
\ No newline at end of file
diff --git a/DefaultGui/DefaultGui/IBackend.cs b/DefaultGui/DefaultGui/IBackend.cs
new file mode 100644
index 0000000..22b61ee
--- /dev/null
+++ b/DefaultGui/DefaultGui/IBackend.cs
@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DefaultGui
+{
+    /// <summary>
+    /// Interface that should be implemented by the class that represents your backend.
+    /// </summary>
+    public interface IBackend
+    {
+        /// <summary>
+        /// Method to get an arbitrary collection of dragons
+        /// </summary>
+        /// <returns>a list of dragons that are currently on the map</returns>
+        List<IPositionable> getDragons();
+        /// <summary>
+        /// Method to get an arbitrary collection of players
+        /// </summary>
+        /// <returns>list of players that are currently on the map</returns>
+        List<IPositionable> getPlayers();
+        /// <summary>
+        /// Method to get a 2d-grid-representation of the map. The map doesn't actually has to be a 2d-array, but you should
+        /// somehow be able to convert it into one.
+        /// </summary>
+        /// <returns>a 2d-array of ITiles, representing the map</returns>
+        ITile[][] getMap();
+        /// <summary>
+        /// Sends a command to the server (such as ask:mv:dwn)
+        /// </summary>
+        /// <param name="command">the command to send</param>
+        void sendCommand(string command);
+        /// <summary>
+        /// Sends a chatmessage to broadcast. This is basically any text, wrapped in the chat-command. 
+        /// So this method will ultimately call sendCommand() after forming a chat-command from the text.
+        /// </summary>
+        /// <param name="message">the text to send as chatmessage</param>
+        void sendChat(string message);
+    }
+}
diff --git a/DefaultGui/DefaultGui/IPositionable.cs b/DefaultGui/DefaultGui/IPositionable.cs
new file mode 100644
index 0000000..e670239
--- /dev/null
+++ b/DefaultGui/DefaultGui/IPositionable.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DefaultGui
+{
+    /// <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 getXPosition();
+        /// <summary>
+        /// Getter for the y-position
+        /// </summary>
+        /// <returns>the y-position</returns>
+        int getYPosition();
+    }
+}
diff --git a/DefaultGui/DefaultGui/ITile.cs b/DefaultGui/DefaultGui/ITile.cs
new file mode 100644
index 0000000..1670d06
--- /dev/null
+++ b/DefaultGui/DefaultGui/ITile.cs
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DefaultGui
+{
+    /// <summary>
+    /// Interface that should be implemented by your class that represents one field in the grid.
+    /// It has to provide methods to check for its properties, which are independed from the way you actually store those properties.
+    /// </summary>
+    public interface ITile : IPositionable
+    {
+        bool isWalkable();
+        bool isForest();
+        bool isHuntable();
+        bool isWater();
+    }
+}
\ No newline at end of file
diff --git a/DefaultGui/DefaultGui/MapCell.cs b/DefaultGui/DefaultGui/MapCell.cs
new file mode 100644
index 0000000..8562b7a
--- /dev/null
+++ b/DefaultGui/DefaultGui/MapCell.cs
@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DefaultGui
+{
+    public class MapCell : ITile
+    {
+        private int x, y;
+        private List<MapCellAttribute> attributes;
+        public MapCell(int x, int y, List<MapCellAttribute> attributes)
+        {
+            this.x = x;
+            this.y = y;
+            this.attributes = new List<MapCellAttribute>();
+            this.attributes.AddRange(attributes);
+        }
+
+        public int getXPosition()
+        {
+            return this.x;
+        }
+
+        public int getYPosition()
+        {
+            return this.y;
+        }
+
+        public bool isWalkable()
+        {
+            return !this.attributes.Contains(MapCellAttribute.UNWALKABLE);
+        }
+
+        public bool isForest()
+        {
+            return this.attributes.Contains(MapCellAttribute.FOREST);
+        }
+
+        public bool isHuntable()
+        {
+            return this.attributes.Contains(MapCellAttribute.HUNTABLE);
+        }
+
+        public bool isWater()
+        {
+            return this.attributes.Contains(MapCellAttribute.WATER);
+        }
+    }
+
+    public enum MapCellAttribute { UNWALKABLE, WATER, FOREST, HUNTABLE }
+}
\ No newline at end of file
diff --git a/DefaultGui/DefaultGui/Program.cs b/DefaultGui/DefaultGui/Program.cs
new file mode 100644
index 0000000..86d1c0a
--- /dev/null
+++ b/DefaultGui/DefaultGui/Program.cs
@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+
+namespace DefaultGui
+{
+    static class Program
+    {
+        /// <summary>
+        /// Der Haupteinstiegspunkt für die Anwendung.
+        /// </summary>
+        [STAThread]
+        static void Main()
+        {
+            Application.EnableVisualStyles();
+            Application.SetCompatibleTextRenderingDefault(false);
+            Application.Run(new DefaultGui(new Backend()));
+        }
+    }
+}