C#

     using System;

namespace WindowsGame1
{
#if WINDOWS || XBOX
    static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        static void Main(string[] args)
        {
            Form1 form = new Form1();
            form.Show();
            Game1 game = new Game1(form.getDrawSurface());
            //game.buttonHit(400,500, true);
            game.Run();
        }
    }
#endif
}

    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        Game1 game1 = new Game1();
        int counter = 1;
            
                   
        public IntPtr getDrawSurface()
        {
            return pctSurface.Handle;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            game1.buttonHit(350, 450, true);
            counter++;
            label1.Text = counter.ToString();
        }

    }
}

    public class Game1 : Microsoft.Xna.Framework.Game
    {
        private GraphicsDeviceManager graphics; // Används för att hantera grafik
        private SpriteBatch spriteBatch; // Används för att rita bilder
        private Player player; // Spelarens objekt  
        private Player player2; // Spelarens objekt
        private Enemy enemy;
        private Texture2D backgroundTexture;
        int screenWidth;
        int screenHeight;
        GraphicsDevice device;
        Rectangle textBox;
        private IntPtr drawSurface;
        int x;
        int y;
        bool isActive = false;
       
        public void buttonHit(int X, int Y, bool IsActive)
        {
            x = X;
            y = Y;
            isActive = IsActive;
        }

        public Game1(IntPtr drawSurface)
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
            this.drawSurface = drawSurface;
            graphics.PreparingDeviceSettings += new EventHandler<PreparingDeviceSettingsEventArgs>(graphics_PreparingDeviceSettings);
            System.Windows.Forms.Control.FromHandle((this.Window.Handle)).VisibleChanged += new EventHandler(Game1_VisibleChanged);
        }

        public Game1()
        { 
        
        }

        

        //param name="sender"></param>
        //<param name="e"></param>
        void graphics_PreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
        {
                e.GraphicsDeviceInformation.PresentationParameters.DeviceWindowHandle =
                drawSurface;
        }
 
        /// <summary>
        /// Occurs when the original gamewindows' visibility changes and makes sure it stays invisible
        /// </summary>
        ///
        //<param name="sender"></param>
        //<param name="e"></param>
        private void Game1_VisibleChanged(object sender, EventArgs e)
        {
                if (System.Windows.Forms.Control.FromHandle((this.Window.Handle)).Visible == true)
                    System.Windows.Forms.Control.FromHandle((this.Window.Handle)).Visible = false;
        }


        /// <summary>
        /// Allows the game to perform any initialization it needs to before starting to run.
        /// This is where it can query for any required services and load any non-graphic
        /// related content.  Calling base.Initialize will enumerate through any components
        /// and initialize them as well.
        /// </summary>
        protected override void Initialize()
        {
            //Istället för att initiera (skapa startvärden) här så gör vi det i Player-klassens konstruktor.
            graphics.PreferredBackBufferWidth = 1500;
            graphics.PreferredBackBufferHeight = 800;
            graphics.IsFullScreen = false;
            graphics.ApplyChanges();
            Window.Title = "Enigma";

            base.Initialize();
            
        }

      
        /// <summary>
        /// LoadContent will be called once per game and is the place to load
        /// all of your content.
        /// </summary>
        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);
            device = graphics.GraphicsDevice;
            //player = new Player(Content.Load<Texture2D>("images/player/ship"), 380, 400, 2.5f, 4.5f); //Lägg till denna. Här skapar du ditt Player-objekt.
            enemy = new Enemy(Content.Load<Texture2D>("images/enemies/uboat2_small"), 0, 0);
            player = new Player(Content.Load<Texture2D>("images/player/Ship"), 300, 400);
            if (isActive == true)
                 player2 = new Player(Content.Load<Texture2D>("images/player/Ship"), x, y);

            // TODO: use this.Content to load your game content here

            backgroundTexture = Content.Load<Texture2D>("images/Background/Atlanten3_1");
            screenWidth = device.PresentationParameters.BackBufferWidth;
            screenHeight = device.PresentationParameters.BackBufferHeight;
        }

        /// <summary>
        /// UnloadContent will be called once per game and is the place to unload
        /// all content.
        /// </summary>
        protected override void UnloadContent()
        {
            // TODO: Unload any non ContentManager content here
        }

        /// <summary>
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Update(GameTime gameTime)
        {
            // Allows the game to exit
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();


            player.update(Window); // Anropa metoden update i player-klassen
            if (isActive == true)
                player2.update(Window); // Anropa metoden update i player-klassen
            //enemy.Update(Window); // Uppdatera fiendens position
     
            
                enemy.Update2(Window, x, y);

       

            base.Update(gameTime);
        }

        /// <summary>
        /// This is called when the game should draw itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);
            spriteBatch.Begin();
            DrawScenery();

            //spriteBatch.Draw(ship_texture, Vector2.Zero, Color.White); //Ta bort denna.
            player.Draw(spriteBatch); // Rita ut spelaren
            if (isActive == true)
                player2.Draw(spriteBatch); // Rita ut spelaren
            //if (player.Y <= 350)
              // enemy.Draw(spriteBatch);

            
            enemy.Draw(spriteBatch);


            spriteBatch.End();

            // TODO: Add your drawing code here

            base.Draw(gameTime);

        }

        private void DrawScenery()
        {
            Rectangle screenRectangle = new Rectangle(0, 0, screenWidth, screenHeight);
            spriteBatch.Draw(backgroundTexture, screenRectangle, Color.White);
        }
    }
}

public abstract class MovingObject : GameObject
{
    public Vector2 ship_speed; // Rymdskeppets hastighet

    // =============================================================
    // MovingObject(), konstuktor för att skapa objektet  : Ärver från konstruktorn i GameObject
    // =============================================================
    //Här äver vi från konstruktor i bas-klassen. Vi måste dock ändå skapa en konstruktor för denna klassen.
    public MovingObject(Texture2D texture, float X, float Y, float speedX, float speedY) : base(texture, X, Y)
    {
           this.ship_speed.X = speedX;
           this.ship_speed.Y = speedY;
    }
}

   }

    public class Player : MovingObject
    {
 bool isAlive = true; // För att hålla koll på om fienden lever eller inte

        public Player(Texture2D texture, float X, float Y) : base(texture, X, Y, 0.05f, 0.05f) //Sätter fart
        {
        }
     
        public void update(GameWindow window)
        {

             KeyboardState keyboardState = Keyboard.GetState();

            // Flytta rymdskeppet efter tangenttryckningar (om det inte är på
            // väg ut från kanten):
            if (ship_vector.X <= window.ClientBounds.Width - texture.Width && ship_vector.X >= 0)
                if (keyboardState.IsKeyDown(Keys.NumPad5))
                    ship_vector.X += 1;


            // Flytta på fienden:
            ship_vector.X -= ship_speed.X;
            ship_vector.Y -= ship_speed.Y;
            // Kontrollera så fienden inte åker utanför fönstret på sidorna
            if (ship_vector.X > window.ClientBounds.Width - texture.Width || ship_vector.X < 0)
                ship_speed.X *= -1; // Byt riktning på fienden
            // Gör fienden inaktiv om den åker ut där nere
            if (ship_vector.Y > window.ClientBounds.Height)
                isAlive = false;
        }
        // 
        public bool IsAlive
        {
            get { return isAlive; }
            set { isAlive = value; }
        }
    }//Here ends class



}

Enemy-class:

<pre lang="c#">

    public class Enemy : MovingObject
    {
        bool isAlive = true; 
      
        public Enemy(Texture2D texture, float X, float Y) : base(texture, X, Y, 0.05f, 0.05f)
        {
        }
        
        public void Update(GameWindow window)
        {
            // Flytta på fienden:
            ship_vector.X += ship_speed.X;
            ship_vector.Y += ship_speed.Y;
            // Kontrollera så fienden inte åker utanför fönstret på sidorna
            if (ship_vector.X > window.ClientBounds.Width - texture.Width || ship_vector.X < 0)
                ship_speed.X *= -1; // Byt riktning på fienden
            // Gör fienden inaktiv om den åker ut där nere
            if (ship_vector.Y > window.ClientBounds.Height)
                isAlive = false;
        }

        public void Update2(GameWindow window, int x, int y)
        {
            ship_vector.X = x;
            ship_vector.Y = y;   
        }
        // =======================================================================
        // Egenskaper för Enemy
        // =======================================================================
        public bool IsAlive
        {
            get { return isAlive; }
            set { isAlive = value; }
        }
    }
}

public class SynchronousSocketListener
{

    // Incoming data from the client.
    public static string data = null;

    public static void StartListening()
    {
        // Data buffer for incoming data.
        byte[] bytes = new Byte[1024];


        // Establish the local endpoint for the socket.
        // Dns.GetHostName returns the name of the 
        // host running the application.
        IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
        IPAddress ipAddress = ipHostInfo.AddressList[0];
        IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);


        // Create a TCP/IP socket.
        Socket listener = new Socket(AddressFamily.InterNetwork,
            SocketType.Stream, ProtocolType.Tcp);

        // Bind the socket to the local endpoint and 
        // listen for incoming connections.
        try
        {
            listener.Bind(localEndPoint);
            listener.Listen(10);

            // Start listening for connections.
            while (true)
            {
                Console.WriteLine("Waiting for a connection...");
                // Program is suspended while waiting for an incoming connection.
                Socket handler = listener.Accept();
                data = null;

                // An incoming connection needs to be processed.
                while (true)
                {
                    bytes = new byte[1024];
                    int bytesRec = handler.Receive(bytes);
                    data += Encoding.ASCII.GetString(bytes, 0, bytesRec);
                    if (data.IndexOf("=)") > -1) //if =) comes in, start notepad.exe
                    {
                        //Insert action after Client is Connected
                        System.Diagnostics.Process.Start(@"C:\Windows\System32\Notepad.exe");
                        break;
                    }
                    if (data.IndexOf("=(") > -1) //if =( comes in, start notepad.exe
                    {
                        //Insert action after Client is Connected
                        System.Diagnostics.Process.Start(@"C:\Windows\System32\cmd.exe");
                        break;
                    }
                   
                }

                // Show the data on the console.
                Console.WriteLine("Text received : {0}", data);

                // Echo the data back to the client.
                byte[] msg = Encoding.ASCII.GetBytes(data);

                handler.Send(msg);
                handler.Shutdown(SocketShutdown.Both);
                handler.Close();
            }

        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }

        Console.WriteLine("\nPress ENTER to continue...");
        Console.Read();

    }

    public static int Main(String[] args)
    {
        StartListening();
        return 0;
    }
}