public static void Main(string[] args)
    {
        Console.WriteLine("GoBang 0.001");
        string host;
        int port;
        if (args.Length < 2)
        {
            host = "localhost";
            port = 7777;

        }
        else
        {
            host = args[0];
            port = int.Parse(args[1]);
        }
        Player one = new NewAiPlayer();
        //Player two = new NewAiPlayer();
        Player two = new Communicator(host, port);

        string color = two.AskColor();
        int size = two.AskSize();

        if (color == "white")
        {
            one.SetColor("white");
            two.SetColor("black");
        }
        else
        {
            Player tmp = one;
            one = two;
            two = tmp;
            one.SetColor("white");
            two.SetColor("black");
        }
        one.SetSize(size);
        two.SetSize(size);

        int[,] board = new int[size, size];
        Coordinate move;
        while (true) {
            move = one.GetMove();
            Console.WriteLine("Got move from player 1: {0}", move);
            if (!valid(board,move))
                throw new Exception("Invalid move " + move);
            board[move.X, move.Y] = 1;
            printBoard(board);
            if (winning(board, 1)) throw new Exception("white has won");
            two.RegOppMove(move);
            move = two.GetMove();
            Console.WriteLine("Got move from player 2: {0}", move);
            if (!valid(board,move))
                throw new Exception("Invalid move " + move);
            board[move.X, move.Y] = -1;
            printBoard(board);
            if (winning(board, -1)) throw new Exception("black has won");
            one.RegOppMove(move);
        }
    }

        public Operations(Communicator communicator)
        {
            this.communicator = communicator;

            databaseConnectionSessionID = this.communicator.CurrentSessionID;
            databaseConnectionCallback = this.communicator.ClientList[databaseConnectionSessionID];
        }

 public MainWindow()
     : base(Gtk.WindowType.Toplevel)
 {
     Build ();
     this._com = new Communicator (new TcpClient ("192.168.0.10", 8888));
     this._vm = new ValueManager (555);
 }

        static void Main()
        {
            try
            {
                _log.InfoFormat("User: {0}", Environment.UserName);

                while (CommunicatorNotRunning())
                {
                    _log.Info("Communicator is not running. Will try again in 5 seconds");
                    System.Threading.Thread.Sleep(5000);
                }

                var communicator = new Communicator(GetRecordHistoryInterval());
                communicator.ConversationEnded += (s, e) => new SaveConversationToFile(_historyFile).Save(e.EventData);

                var notifyIcon = MakeNotifyIcon();
                notifyIcon.Visible = true;
                Application.Run();
                notifyIcon.Visible = false;
                communicator.Dispose();
            }
            catch (Exception e)
            {
                _log.Error("Exception caught", e);
            }
        }

 // Receive in a seperate thread
 public MessageHandler(MainGrid active_grid)
 {
     c = Communicator.GetInstance(active_grid);
     ThreadStart ts = new ThreadStart(c.ReceiveData);
     Thread t = new Thread(ts,50000000);
     t.Start();
 }

 public PluginManagerI(Communicator communicator)
 {
     _communicator = communicator;
     _plugins = new Hashtable();
     _initOrder = new ArrayList();
     _initialized = false;
 }

        public TempCommunicator(string configFileClasspath)
        {
            log("Constructor called");
            try
            {
                InitializationData initData = new InitializationData();
                initData.properties = Util.createProperties();
                initData.properties.load(configFileClasspath);
                communicator = Util.initialize(initData);
                log("Properties Loaded!");
            }
            catch (Exception e)
            {
                log(e.ToString());
                throw e;
            }
            string proxy1 = "'::TeRK::TeRKUser':tcp -h 127.0.0.1 -p 10101";
            log("Calling stringToProxy on " + proxy1);
            communicator.stringToProxy(proxy1);
            log("Complete!");

            string proxy2 = "'::TeRK::TeRKUser':tcp -h 192.168.0.16 -p 10101";
            log("Calling stringToProxy on " + proxy2);
            communicator.stringToProxy(proxy2);
            log("Complete!");

            log("Constructor terminated");
            writeLog("C:\\tempCommLog.txt");
        }

 private void client_ConnexionRemoved(Communicator c, IConnexion conn)
 {
     /* if (!IsDisposed && client.Connexions.Count == 0)
     {
         MessageBox.Show(this, "Disconnected from server", Text);
         Close();
     } */
 }

        public MainForm()
        {
            InitializeComponent();            

            _communicator = Communicator.getInstance();

            _activeTalks = new List<Talk>();            
        }

    public static Communicator getInstance()
    {
        if (instance == null)
        {
            instance = new Communicator();
        }

        return instance;
    }

 static void Main(string[] args)
 {
     Console.WriteLine("Server started.");
     var settings = LoadSettings("Settings.txt");
     GameStateServer gameState = new GameStateServer(settings.Map);
     Communicator communicator = new Communicator(settings.ServerPort, settings.ServerConnectionPort, gameState);
     Console.ReadKey();
     System.Threading.Thread.Sleep(5000);
 }

 public void GetGameConfiguration(Action<Response<GameConfiguration>> callback)
 {
     var payload = new Dictionary<string, object>(0);
      var communicator = new Communicator(this);
      communicator.SendPayload<GameConfiguration>(Communicator.POST, "conf", payload, r =>
      {
     if (r.Success) { r.Data = JsonConvert.DeserializeObject<GameConfiguration>(r.Raw); }
     callback(r);
      });
 }

        public PingTimesForm(Communicator comm)
        {
            InitializeComponent();
            _pingTimes.ClearData(ClearDataFlag.Values);
            _pingTimes.AxisX.Min = 0;

            Text += ": " + comm;
            _observed = comm;
            _statsObserver = CommunicationStatisticsObserver<Communicator>.On(comm);
        }

 public void AchievementEarned(string achievementId, string userName, string uniqueIdentifier, Action<Response<Achievement>> callback)
 {
     var payload = new Dictionary<string, object> { { "aid", achievementId }, { "username", userName }, { "userkey", uniqueIdentifier } };
      var communicator = new Communicator(this);
      communicator.SendPayload<Achievement>(Communicator.Post, "achievements", payload, r =>
      {
     if (r.Success) { r.Data = JsonConvert.DeserializeObject<Achievement>(r.Raw); }
     if (callback != null) { callback(r); }
      });
 }

 public void GetAssets(Action<Response<IList<Asset>>> callback)
 {
     var payload = new Dictionary<string, object> {{"key", Key}};
      var communicator = new Communicator(this);
      communicator.SendPayload<IList<Asset>>(Communicator.Get, "assets", payload, r =>
      {
     if (r.Success) { r.Data = JsonConvert.DeserializeObject<IList<Asset>> (r.Raw); }
     if (callback != null) { callback(r); }
      });
 }

 public MainWindow()
 {
     InitializeComponent();
     comm = Communicator.Instance;
     this.Background = ThemeParser.GetColor(ThemeParser.Colors.Background);
     comm.ConnectionStatusChanged += new EventHandler<ConnectionStatusChangedEventArgs>(comm_ConnectionStatusChanged);
     comm.DataRecieved += new EventHandler<DataReceivedEventArgs>(comm_DataRecieved);
     mHandler.NewIncomingMessage += new EventHandler<NewIncomingMessageEventArgs>(mHandler_NewIncomingMessage);
     this.Closing += new System.ComponentModel.CancelEventHandler(MainWindow_Closing);
     this.Loaded += new RoutedEventHandler(MainWindow_Loaded);
 }

 public void LogAsync(string message, Action<LogResponse> callback)
 {
     var communicator = new Communicator(this);
     var callbackWrapper = callback == null ? (Action<Response>) null : r =>
     {
     if (r.Success)
     {
         callback(JsonConvert.DeserializeObject<LogResponse>(r.Raw));
     }
     };
     communicator.SendPayload(Communicator.POST, string.Concat("inputs/", _inputKey), message, callbackWrapper);
 }

     ThreadHookPlugin(Communicator communicator, ThreadNotification threadHook)
     {
         if(communicator == null)
         {
             PluginInitializationException ex = new PluginInitializationException();
             ex.reason = "Communicator cannot be null";
             throw ex;
         }
 
         IceInternal.Instance instance = IceInternal.Util.getInstance(communicator);
         instance.setThreadHook(threadHook);
     }

 public void GetGameVersion(Action<Response<int>> callback)
 {
     var payload = new Dictionary<string, object>(0);
      var communicator = new Communicator(this);
      communicator.SendPayload<int>(Communicator.POST, "conf/version", payload, r =>
      {
     if (r.Success)
     {
        var container = ((JContainer) JsonConvert.DeserializeObject(r.Raw))["version"];
        r.Data = container == null ? 0 : container.Value<int>();
     }
     callback(r);
      });
 }

 public void TestWrite()
 {
     using (MemoryStream stream = new MemoryStream())
     {
         Communicator communicator = new Communicator(
             new StreamSimpleCommunicator<object>(stream, null));
         foreach (object message in
             new object[] { new A { UIntValue = 1 }, new A { UIntValue = 2 } })
         {
             communicator.Send(message);
         }
         AssertExtensions.AreEqual(
             new byte[] { 0x02, 0x08, 0x01, 0x02, 0x08, 0x02 },
             stream.ToArray());
     }
 }