/// <summary>
        /// This is used to indicate in which direction the image is "looking"
        /// </summary>
        public enum ImageDirection
        {
            Top,
            Right,
            Bottom,
            Left
        }

        /// <summary>
        /// Calculates the angle between 2 Vectors
        /// </summary>
        /// <param name="p1">Vector 1</param>
        /// <param name="p2">Vector 2</param>
        /// <returns>Angle between the vectors</returns>
        public static float GetAngle(Point vectorA, Point vectorB);

        /// <summary>
        /// Calculates the angle
        /// </summary>
        /// <param name="p1">Point, where the image should be placed</param>
        /// <param name="p2">Point, where the image should "look" to</param>
        /// <param name="direction">The direction, where the image is "looking" actually</param>
        /// <returns>The Angle, that would be needed to rotate the image to "look" at p2</returns>
        public static float GetAngle(Point p1, Point p2, ImageDirection direction);

        public static Bitmap RotateImage (Bitmap image, float angle);

        static long rnd = DateTime.Now.Ticks;

        static void Main(string[] args)
        {
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine(i + ": " + get_random);
            }
            Console.ReadLine();
        }

        static long get_random
        {
            get
            {
                rnd = (rnd * 110671L + 1263L) & 167215L;
                return rnd;
            }
        }

public void Print2Console()
        {
            for (int i = 0; i < field.GetLength(0); i++)
            {
                for (int j = 0; j < field.GetLength(1)*2+1; j++)
                {
                    Console.Write("-");
                }
                Console.WriteLine();
                Console.Write("|");
                for (int j = 0; j < field.GetLength(1); j++)
                {
                    Console.Write(field[i, j].ToString() + "|");
                    System.Threading.Thread.Sleep(10); //Somit 'sieht' man den Aufbau
                }
                Console.WriteLine();
            }
        }

public static void PrintField(object[,] field, (enum/flag) PrintOption, int sleepTime)

static void Main(string[] args)
        {
            int bufferCount = 5;
            Random rand = new Random();
            IntPtr device = OpenAL.ALC.OpenDevice(null);
            IntPtr context = OpenAL.ALC.CreateContext(device, null);
            OpenAL.ALC.MakeContextCurrent(context);
            uint source;
            OpenAL.AL.GenSources(1, out source);
            uint[] buffers = new uint[bufferCount];
            OpenAL.AL.GenBuffers(bufferCount, buffers);
            OpenAL.AL.SourceUnqueueBuffers(source, bufferCount, buffers);
            for (int i = 0; i < bufferCount; i++)
            {
                short[] wave = GenerateSound(rand.Next(3000, 8001), rand.Next(500, 2001));
                OpenAL.AL.BufferData(buffers[i], AlAudioFormat.Mono16Bit, wave, wave.Length, 1000);
            }
            OpenAL.AL.SourceQueueBuffers(source, bufferCount, buffers);
            OpenAL.AL.SourcePlay(source);
            int act = 0;
            while (true)
            {
                int proc = OpenAL.AL.GetSourcei(source, OpenAL.AlSourceInts.Buffers_Processed);
                if (proc > 0)
                {
                    OpenAL.AL.SourceUnqueueBuffers(source, 0);
                    short[] wave = GenerateSound(rand.Next(3000, 8001), rand.Next(500, 2001));
                    OpenAL.AL.BufferData(buffers[act], AlAudioFormat.Mono16Bit, wave, wave.Length, 1000);
                    act++;
                    if (act == bufferCount) { act = 0; }
                    OpenAL.AL.SourceQueueBuffer(source, buffers[act]);
                }
            }
        }

        static short[] GenerateSound(int sampleRate, int frequenz)
        {
            short[] waves = new short[sampleRate];
            short amplitude = short.MaxValue / 2;
            for (int n = 0; n < waves.Length; n++)
            {
                waves[n] = (short)(amplitude * Math.Sin((2 * Math.PI * n * frequenz) / sampleRate));
            }
            return waves;
        }

        static void Main(string[] args)
        {
            IntPtr device = OpenAL.ALC.OpenDevice(null);
            IntPtr context = OpenAL.ALC.CreateContext(device, null);
            OpenAL.ALC.MakeContextCurrent(context);
            uint sources;
            OpenAL.AL.GenSources(1, out sources);
            short[] wave = GenerateWave(8000, 1000);
            uint buffer = OpenAL.AL.GenBuffer();
            OpenAL.AL.SourceUnqueueBuffers(sources, 1);
            OpenAL.AL.BufferData(buffer, AlAudioFormat.Mono16Bit, wave, wave.Length, 1000);
            OpenAL.AL.SourceQueueBuffers(sources, 1, ref buffer);
            while (true)
            {
                OpenAL.AL.SourcePlay(sources);
                System.Threading.Thread.Sleep(1500);
            }
        }

        static short[] GenerateWave(int sampleRate, int frequenz)
        {
            short[] waves = new short[sampleRate];
            short amplitude = short.MaxValue / 8;
            for (int n = 0; n < waves.Length; n++)
            {
                waves[n] = (short)(amplitude * Math.Sin((2 * Math.PI * n * frequenz) / sampleRate));
            }
            return waves;
        }

public class BinaryTree<T> where T: IComparable<T>
{
      public bool Remove(T data) {}
      public void Insert(T data) {}
      public bool Contains(T data) {}
      public void Clear() {}
      public int Count { get { return this.count; }}
      public T this[int index] { get; set; }
}

class Program
    {
        static List<int> permutation = new List<int>();
        static List<List<int>> solutions = new List<List<int>>();
        static void Main(string[] args)
        {
            Console.WriteLine("Count Permutations!\n\n");
            Console.Write("Höchstmögliche Zahl [1 .. n]: ");
            int n, min, max;
            while (!int.TryParse(Console.ReadLine(), out n))
            {
                Console.Write("Ungültige Eingabe! Erneuter Versuch: ");
            }
            Console.Write("Minimaler Abstand: ");
            while (!int.TryParse(Console.ReadLine(), out min))
            {
                Console.Write("Ungültige Eingabe! Erneuter Versuch: ");
            }
            Console.Write("Maximaler Abstand: ");
            while (!int.TryParse(Console.ReadLine(), out max))
            {
                Console.Write("Ungültige Eingabe! Erneuter Versuch: ");
            }
            int ret = CountPermutations(n, min, max, 1, true);
            Console.Write("{0} Lösungen gefunden! Sollen die Lösungen ausgegeben werden? [N/y]: ", ret);
            if (Console.ReadLine().ToLower() == "y")
            {
                Console.WriteLine();
                foreach (List<int> perm in solutions)
                {
                    Console.Write("[");
                    foreach (int item in perm)
                    {
                        Console.Write(item.ToString() + " ");
                    }
                    Console.Write("]\n");
                }
                Console.ReadLine();
            }
        }

        /// <summary>
        /// Berechnet die Anzahl der Permutation von [1,...,n], bei denen der
        /// Absolutbetrag der Differenz zweier aufeinanderfolgender Zahlen zwischen
        /// min und max liegt. (min ≤ max ≤ n)
        /// </summary>
        /// <param name="n">Anzahl und Werte der Elemente (n Elemente mit den Werten 1-n)</param>
        /// <param name="min">Minimaler Abstand zwischen zwei aufeinanderfolgenden Elementen (inklusive)</param>
        /// <param name="max">Maximaler Abstand zwischen zwei aufeinanderfolgenden Elementen (inklusive)</param>
        /// <returns>Anzahl der möglichen Permutationen</returns>
        public static int CountPermutations(int n, int min, int max, int act, bool basicCall)
        {
            //Rekursiver Ausstieg
            if (act > n || act < 1 || permutation.Contains(act)) //Außerhalb des Definitionsbereiches!
            {
                return -1;
            }
            //Da wir innerhalb des Bereiches sind - gültige Zahl hinzufügen!
            permutation.Add(act);
            if (permutation.Count == n) //Lösung gefunden!
            {
                List<int> list = new List<int>(permutation);
                solutions.Add(list);
                permutation.RemoveAt(permutation.Count - 1); //Letztes Element wieder entfernen
                return -1; //Da wir alle Lösungen wollen, geben wir an, keine Lösung gefunden zu haben!
            }
            //Rekursiver Abstieg
            for (int i = min; i ≤ max; i++)
            {
                CountPermutations(n, min, max, act + i, false);
                CountPermutations(n, min, max, act - i, false);
            }
            if (basicCall)
            {
                permutation.Clear();
                act++;
                CountPermutations(n, min, max, act, true);
            }
            permutation.Remove(act);
            return solutions.Count;
        }
    }

 public void FindString()
            {
                // TODO Hier seid ihr gefragt!
                StringBuilder guess = new StringBuilder();
                int erg = 0;
                do
                {
                    guess = guess.Append((char)64);
                    erg = stringHider.Ask(guess.ToString());
                } while (erg == -1);
                int len = guess.Length;
                for (int i = 0; i < len; i++)
                {
                    for (int v = 0; v < 26; v++)
                    {
                        guess[i]++;
                        int asked = stringHider.Ask(guess.ToString());
                        if (asked > erg || asked == -2)
                        {
                            erg++;
                            break;
                        }
                    }
                }
           }

 public void FindString()
            {
                // TODO Hier seid ihr gefragt!
                object erg = typeof(StringHider).InvokeMember("value", BindingFlags.GetField | BindingFlags.Instance | BindingFlags.NonPublic, null, stringHider, null);
                string asking = (string)erg;
                int ret = stringHider.Ask(asking);
            }

  public partial class DrawBoard : Form
    {
        public MovingObject ship;
        public MovingObject ast;
        public MovingObject shot;

        public DrawBoard(MovingObject a, MovingObject b) : this(a, b, null)
        {
        }

        public DrawBoard(MovingObject a, MovingObject b, MovingObject c)
        {
            InitializeComponent();
            ship = a;
            ast = b;
            shot = c;
            Timer t = new Timer();
            t.Interval = 500;
            t.Tick += new EventHandler(t_Tick);
            t.Start();
        }

        void t_Tick(object sender, EventArgs e)
        {
            if (ship != null)
            {
                ship.Move();
            }
            if (ast != null)
            {
                ast.Move();
            }
            if (shot != null)
            {
                shot.Move();
            }
            this.Invalidate();
            if (shot.x == ast.x && shot.y == ast.y)
            {
                MessageBox.Show("TREFFER!");
            }
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            Graphics draw = e.Graphics;
            {//DrawGraph
                    Pen gray = new Pen(Brushes.Gray, 1F);
                    int max = 200; // constant     |
                    int abstand = 50; // constant  > change for graphstyle
                    for (int i = 0; i < max; i++)
                    {
                        draw.DrawLine(gray, new Point(i * abstand, 0), new Point(i * abstand, max * abstand));
                        draw.DrawLine(gray, new Point(0, i * abstand), new Point(max * abstand, i * abstand));
                        draw.DrawString((i * abstand).ToString() + "px", new Font(FontFamily.GenericSansSerif, 7F), Brushes.Black, new PointF(abstand * i, 0));
                        draw.DrawString((i * abstand).ToString() + "px", new Font(FontFamily.GenericSansSerif, 7F), Brushes.Black, new PointF(0, abstand * i));
                    }
            } //End DrawGraph
            //Draw the Objects
            if (ship != null)
            {
                Pen black = new Pen(Brushes.Black, 2F);
                draw.DrawEllipse(black, ship.x * 40, ship.y * 40, ship.r * 10, ship.r * 10);
            }
            if (ast != null)
            {
                Pen blue = new Pen(Brushes.Blue, 2F);
                draw.DrawEllipse(blue, ast.x * 40, ast.y * 40, ast.r * 10, ast.r * 10);
            }
            if (shot != null)
            {
                Pen green = new Pen(Brushes.Green, 1.5F);
                draw.DrawEllipse(green, shot.x * 40, shot.y * 40, shot.r * 10, shot.r * 10);
            }
            //Draw line for movement
            Pen red = new Pen(Brushes.Red, 1F);
            draw.DrawLine(red, new Point(ship.x * 40, ship.y * 40), new Point(ship.dx * 40, ship.dy * 40));
            draw.DrawLine(red, new Point(ast.x * 40,ast.y * 40), new Point(ast.dx * 40, ast.dy * 40));
            draw.DrawLine(red, new Point(shot.x * 40, shot.y * 40), new Point(shot.dx * 40, shot.dy * 40));
        }
        

        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.SuspendLayout();
            // 
            // DrawBoard
            // 
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(365, 262);
            this.Name = "DrawBoard";
            this.Text = "DrawBoard";
            this.ResumeLayout(false);

        }

        #endregion
    }

Console.WindowHeight
Console.WindowWidth