bool Game::Move_UpAI(int i,int j)
{
	if (i != 0 && Matrix[i - 1][j] == 0)
	{
		Matrix[i - 1][j] = Matrix[i][j];
		Matrix[i][j] = 0;
		ChessY[Matrix[i][j] - 1] += 0.2;
		std::cout << "MoveUp AI" << std::endl;
		return true;
	}
	else
		return false;
}
void Game::ReccurentWalk(int numbernotuse)
{
	current = -1, currentI = -1, currentJ = -1;
	for (int i = 10; i < 18; i++)
		if (!ai[i] )
		{
			current = i;
			if (current == numbernotuse)
				continue;
			break;
		}
	for (int i = 0; i < 8; i++)
		for (int j = 0; j < 8; j++)
			if (Matrix[i][j] == current)
			{
				currentI = i;
				currentJ = j;
				break;
			}
	if (!Move_UpAI(currentI, currentJ))
		if(!Move_LeftAI(currentI, currentJ))
		{
			ReccurentWalk(current);
		}
	//	Move_LeftAI(currentI, currentJ);
}
void Game::AI()
{
	if (secondplayer)
	{
		secondplayer = false;
		firstplayer = true;
		ReccurentWalk(-2);
		if (currentI == 0 && currentJ == 0)
		{
			ai[9] = true;
			ReccurentWalk(9);
		}

bool flag = true;
void Render()
{
    while(not_exit)
    {
        do_something();
        keyboard();
        if(flag)
            do_one_time();
    }
}
void do_one_time()
{
    ...
    flag = false;
}
void keyboard()
{
    if(key == f1)
        flag = true;
    if(key==f2)
    {
        ...
    }
    ...
}
void main()
{
    Init();
    Render();
    Release();
}

#include <iostream>
#include <fstream>
#include <vector>
bool f(char c)
{
  if (c == ' ' || c == ',' || c == '.' || c == '?'
    || c == ':' || c == ';' || c == '<'
    || c == '>' || c == '!' || c == '-' || c=='\n' ||
    c == '1' || c == '2' || c == '3' || c == '4'
    || c == '5' || c == '6' || c == '7'
    || c == '8' || c == '9' || c == '0')
    return true;
  else
    return false;
}
int main()
{
  std::vector<std::pair<int, std::string>> v;
  std::pair<int, std::string> p;
  setlocale(LC_ALL, "en_US.UTF-8");
  char buff[255]; // буфер промежуточного хранения считываемого из файла текста
  std::ifstream fin("text.txt"); // (ВВЕЛИ НЕ КОРРЕКТНОЕ ИМЯ ФАЙЛА)
  std::ofstream fout("word.txt"); // создаём объект класса ofstream для записи и связываем его с файлом cppstudio.txt
  if (!fin.is_open()) // если файл не открыт
    std::cout << "Файл не может быть открыт!\n"; // сообщить об этом
  else
  {
    //fin >> buff; // считали первое слово из файла
    //std::cout << buff << std::endl; // напечатали это слово
    std::string str;
    while (fin.getline(buff, 255))
    {
      for (int i = 0; i < 255; i++)
      {
        
        if(f(buff[i]))
        {
          p.first = 0;
          p.second = str;
          std::cout << str << std::endl;
          fout <<str<<'\n'; // запись строки в файл
          v.push_back(p);
          str.clear();
        }
        else
          str += buff[i];
      }
    } // считали строку из файла
    fin.close(); // закрываем файл
    //std::cout << buff << std::endl; // напечатали эту строку
  }
  fout.close();
  return 0;
}

package example;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;
/**
 *
 * @author User
 */
public class Example {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws Exception {    
String ip = "";
        ip=getCurrentIP();
        System.out.println(ip);
    }
private static String getCurrentIP() {
        String result = null;
        try {
            BufferedReader reader = null;
            try {
                URL url = new URL("http://myip.by/");
                InputStream inputStream = null;
                inputStream = url.openStream();
                reader = new BufferedReader(new InputStreamReader(inputStream));
                StringBuilder allText = new StringBuilder();
                char[] buff = new char[10240];
 
                int count = 0;
                while ((count = reader.read(buff)) != -1) {
                    allText.append(buff, 0, count);
                }
// Строка содержащая IP имеет следующий вид 
// <a href="whois.php?127.0.0.1">whois 127.0.0.1</a> 
                Integer indStart = allText.indexOf("\">whois ");
                Integer indEnd = allText.indexOf("</a>", indStart);
 
                String ipAddress = new String(allText.substring(indStart + 8, indEnd));
                if (ipAddress.split("\\.").length == 4) { // минимальная (неполная) 
                //проверка что выбранный текст является ip адресом.
                    result = ipAddress;
                }
            } catch (MalformedURLException ex) {
                 ex.printStackTrace();
            } catch (IOException ex) {
                 ex.printStackTrace();
            } finally {
                if (reader != null) {
                    try {
                        reader.close();
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        return result;
    }
}

<p align="center">
<iframe width="560" height="315" src="https://www.youtube.com/watch?v=Bt4P5mRJv0Y" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen></iframe>
</p>

int Game::Execute()
{
  bool fullscreen = false;
  SDL_GLContext context;
  SDL_Init(SDL_INIT_VIDEO);
  diagwindow = SDL_CreateWindow("Settings", 10, 10,700 ,500, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN);
  window = SDL_CreateWindow("Tropic Island", 10, 10,700 ,500, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN);
  context = SDL_GL_CreateContext(window);
  SDL_GL_SetSwapInterval(1);

  setup_opengl(700,500);
....

struct WAVHEADER
{
  // WAV-формат начинается с RIFF-заголовка:

  // Содержит символы "RIFF" в ASCII кодировке
  // (0x52494646 в big-endian представлении)
  char chunkId[4];

  // 36 + subchunk2Size, или более точно:
  // 4 + (8 + subchunk1Size) + (8 + subchunk2Size)
  // Это оставшийся размер цепочки, начиная с этой позиции.
  // Иначе говоря, это размер файла - 8, то есть,
  // исключены поля chunkId и chunkSize.
  unsigned long chunkSize;

  // Содержит символы "WAVE"
  // (0x57415645 в big-endian представлении)
  char format[4];

  // Формат "WAVE" состоит из двух подцепочек: "fmt " и "data":
  // Подцепочка "fmt " описывает формат звуковых данных:

  // Содержит символы "fmt "
  // (0x666d7420 в big-endian представлении)
  char subchunk1Id[4];

  // 16 для формата PCM.
  // Это оставшийся размер подцепочки, начиная с этой позиции.
  unsigned long subchunk1Size;

  // Аудио формат, полный список можно получить здесь http://audiocoding.ru/wav_formats.txt
  // Для PCM = 1 (то есть, Линейное квантование).
  // Значения, отличающиеся от 1, обозначают некоторый формат сжатия.
  unsigned short audioFormat;

  // Количество каналов. Моно = 1, Стерео = 2 и т.д.
  unsigned short numChannels;

  // Частота дискретизации. 8000 Гц, 44100 Гц и т.д.
  unsigned long sampleRate;

  // sampleRate * numChannels * bitsPerSample/8
  unsigned long byteRate;

  // numChannels * bitsPerSample/8
  // Количество байт для одного сэмпла, включая все каналы.
  unsigned short blockAlign;

  // Так называемая "глубиная" или точность звучания. 8 бит, 16 бит и т.д.
  unsigned short bitsPerSample;

  // Подцепочка "data" содержит аудио-данные и их размер.

  // Содержит символы "data"
  // (0x64617461 в big-endian представлении)
  char subchunk2Id[4];

  // numSamples * numChannels * bitsPerSample/8
  // Количество байт в области данных.
  unsigned long subchunk2Size;

  // Далее следуют непосредственно Wav данные.
};
int j = 0;
#ifdef _WIN32
  file = open("content//konga.wav", _A_ARCH);
#else
  file = open(filename, O_RDONLY);
#endif // _WIN32
  if (file == -1)
  {
    printf("Open failed on input file: %s\n", "content//konga.wav");
#ifdef _WIN32
    wchar_t path[MAX_PATH];
    GetCurrentDirectory(sizeof(path), path);
    std::wcout << path << std::endl;
#endif // _WIN32
  }
  org = 0;

  FILE* file_;
  errno_t err;
  err = fopen_s(&file_, "content//konga.wav", "rb");
  if (err)
  {
    printf_s("Failed open file, error %d", err);
    return 0;
  }

  WAVHEADER header;

  fread_s(&header, sizeof(WAVHEADER), sizeof(WAVHEADER), 1, file_);
  printf("audioformat:%d\n", header.audioFormat);
  printf("bitsPerSample:%d\n", header.bitsPerSample);
  printf("blockAlign:%d\n", header.blockAlign);
  printf("byteRate:%lu\n", header.byteRate);
  printf("chunkId:%s\n", header.chunkId);
  printf("chunkSize:%lu\n", header.chunkSize);
  printf("format:%s\n", header.format);
  printf("numCannels:%d\n", header.numChannels);
  printf("sampleRate:%lu\n", header.sampleRate);
  printf("subchunk1Id:%s\n", header.subchunk1Id);
  printf("subchunk1Size:%lu\n", header.subchunk1Size);
  printf("subchunk2Id:%s\n", header.subchunk2Id);
  printf("subchunk2Size:%lu\n", header.subchunk2Size);
  fclose(file_);

#include <stdio.h>
#include <stdlib.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/socket.h>
	#include <netinet/in.h>
	#include <netdb.h>
	#include <arpa/inet.h>
	#include <pthread.h>
        int sockfd
        , portno
        , n
        ,*newsockfd
        ,id
        ,clients
        ,currentclient=0;
        ;
        socklen_t clilen;
        struct sockaddr_in serv_addr
        ,cli_addr;
        struct hostent *server;
        char* name;
        char buffer[2][256];
int Init()
{
		sockfd = socket(AF_INET, SOCK_STREAM, 0);
		if (sockfd < 0)
	        error("ERROR opening socket");
		bzero((char *) &serv_addr, sizeof(serv_addr));
		serv_addr.sin_family = AF_INET;
		if(id==0)
			serv_addr.sin_addr.s_addr = INADDR_ANY;
		else
			serv_addr.sin_addr.s_addr = inet_addr(name);
		serv_addr.sin_port = htons(portno);
		if(id==0)
		{
	        if (bind(sockfd, (struct sockaddr *) &serv_addr,sizeof(serv_addr)) < 0)
				error("ERROR on binding");
		}
		else
		{
	        if (connect(sockfd,(struct sockaddr *) &serv_addr,sizeof(serv_addr)) < 0)
		        error("ERROR connecting");
		}
		if(id == 0)
		{
	        listen(sockfd,5);
		    clilen = sizeof(cli_addr);

			newsockfd[currentclient] = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);
			if (newsockfd < 0)
				error("ERROR on accept");
            currentclient++;
		}
	return 0;
}
void *a(void *args)
{
    while(1)
    {
        newsockfd[currentclient] = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);
        if (newsockfd[currentclient]< 0)
            error("ERROR on accept");
        currentclient++;
    }
}
void error(const char *msg)
{
    perror(msg);
    close(sockfd);
	exit(1);
}
int Close()
{
    close(sockfd);
    if(id == 0)
        close(newsockfd);
	return 0;
}
void Send(int numberclient,int numberbuf)
{
    if(id == 0)
        n = write(newsockfd[numberclient],buffer[numberbuf],255);
    else
        n = write(sockfd,buffer[numberbuf],strlen(buffer));
    if (n < 0) error("ERROR writing to socket");
        bzero(buffer,256);
}
void Recv(int numberclient,int numberbuf)
{
	if(id == 0)
		n = read(  newsockfd[numberclient] ,buffer[numberbuf],255);
	else
		n = read(  sockfd ,buffer[numberbuf],255);
    if (n < 0) error("ERROR reading from socket");
}
void SetBuf(char * s,int numberbuf)
{
    bzero(buffer[numberbuf],256);
    unsigned int i;
    for(i = 0;i<strlen(s);i++)
        buffer[numberbuf][i] = s[i];
}
void ClearBuf(int numberbuf)
{
    bzero(buffer[numberbuf],256);
}
char * GetBuf(int numberbuf)
{
    return buffer[numberbuf];
}
void SetName(char *name_)
{
    name = name_;
}
void SetPort(int portno_)
{
    portno = portno_;
}
const int length = 256;
char *text;
typedef struct
{
    int numberclient;
    int numberbuf;
}clientdata;
void s(void *numbers)
{
    clientdata *data = (clientdata*)numbers;
    data->numberbuf = 1;
    while(1)
    {
        ClearBuf(data->numberbuf);
        //Sleep(1);
        //scanf("%s",text);
        SetBuf(text,data->numberbuf);
        Send(data->numberclient,data->numberbuf);
        //if(text[0] == '0')
          //  break;
    }
}
void r(void *numbers)
{
    clientdata *data = (clientdata*)numbers;
    data->numberbuf = 0;
    while(1)
    {
        ClearBuf(data->numberbuf);
        //Sleep(1);
        Recv(data->numberclient,data->numberbuf);
        printf("%s",GetBuf(data->numberbuf));
        //if(GetBuf(data->numberbuf)[0] == '0')
           // break;
    }
}
int main()
{
    text = "azaza";
    printf("Enter clients count\n");
    scanf("%d",&clients);
    newsockfd = (int*)malloc(sizeof(int)*clients);
    pthread_t threadsend,threadreceive,threadaccept;
    text = (char*)malloc(sizeof(char)*length);
    id = 0;
	printf("input port number\n");
	int port;//=15000;
	scanf("%d",&port);
	SetPort(port);
	Init();
	pthread_create(&threadaccept,NULL,a,NULL/*(void*)currentclient*/);
	clientdata *d;
	for(int i=0;i<clients;i++)
    {
        d->numberclient = i;
        pthread_create(&threadreceive,NULL,r,(void*)d);
        pthread_create(&threadsend,NULL,s,(void*)d);
        //pthread_join(threadreceive,NULL);
        //pthread_join(threadsend,NULL);
	}
        //r(i);
	Close();
	//system("pause");
	free(text);
	free(newsockfd);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/socket.h>
	#include <netinet/in.h>
	#include <netdb.h>
	#include <arpa/inet.h>
	#include <pthread.h>
        int sockfd
        , portno
        , n
        ,*newsockfd
        ,id
        ,clients
        ,currentclient=0;
        ;
        socklen_t clilen;
        struct sockaddr_in serv_addr
        ,cli_addr;
        struct hostent *server;
        char* name;
        char buffer[2][256];
int Init()
{
		sockfd = socket(AF_INET, SOCK_STREAM, 0);
		if (sockfd < 0)
	        error("ERROR opening socket");
		bzero((char *) &serv_addr, sizeof(serv_addr));
		serv_addr.sin_family = AF_INET;
		if(id==0)
			serv_addr.sin_addr.s_addr = INADDR_ANY;
		else
			serv_addr.sin_addr.s_addr = inet_addr(name);
		serv_addr.sin_port = htons(portno);
		if(id==0)
		{
	        if (bind(sockfd, (struct sockaddr *) &serv_addr,sizeof(serv_addr)) < 0)
				error("ERROR on binding");
		}
		else
		{
	        if (connect(sockfd,(struct sockaddr *) &serv_addr,sizeof(serv_addr)) < 0)
		        error("ERROR connecting");
		}
		if(id == 0)
		{
	        listen(sockfd,5);

		    clilen = sizeof(cli_addr);
			newsockfd[currentclient] = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);
			if (newsockfd < 0)
				error("ERROR on accept");
            currentclient++;
		}
	return 0;
}
void error(const char *msg)
{
    perror(msg);
    close(sockfd);
	exit(1);
}
int Close()
{
    close(sockfd);
    if(id == 0)
        close(newsockfd);
	return 0;
}
void Send(int numberclient,int numberbuf)
{
    if(id == 0)
        n = write(newsockfd[numberclient],buffer[numberbuf],255);
    else
        n = write(sockfd,buffer[numberbuf],strlen(buffer));
    if (n < 0) error("ERROR writing to socket");
        bzero(buffer,256);
}
void Recv(int numberclient,int numberbuf)
{
	if(id == 0)
		n = read(  newsockfd[numberclient] ,buffer[numberbuf],255);
	else
		n = read(  sockfd ,buffer[numberbuf],255);
    if (n < 0) error("ERROR reading from socket");
}
void SetBuf(char * s,int numberbuf)
{
    bzero(buffer[numberbuf],256);
    unsigned int i;
    for(i = 0;i<strlen(s);i++)
        buffer[numberbuf][i] = s[i];
}
void ClearBuf(int numberbuf)
{
    bzero(buffer[numberbuf],256);
}
char * GetBuf(int numberbuf)
{
    return buffer[numberbuf];
}
void SetName(char *name_)
{
    name = name_;
}
void SetPort(int portno_)
{
    portno = portno_;
}
const int length = 256;
char *text;
typedef struct
{
    int numberclient;
    int numberbuf;
}clientdata;
void s(void *numbers)
{
    clientdata *data = (clientdata*)numbers;
    data->numberbuf = 1;
    while(1)
    {
        ClearBuf(data->numberbuf);
        //Sleep(1);
        //scanf("%s",text);
        SetBuf(text,data->numberbuf);
        Send(data->numberclient,data->numberbuf);
        //if(text[0] == '0')
          //  break;
    }
}
void r(void *numbers)
{
    clientdata *data = (clientdata*)numbers;
    data->numberbuf = 0;
    while(1)
    {
        ClearBuf(data->numberbuf);
        //Sleep(1);
        Recv(data->numberclient,data->numberbuf);
        printf("%s",GetBuf(data->numberbuf));
        //if(GetBuf(data->numberbuf)[0] == '0')
           // break;
    }
}
int main()
{
    id = 1;
	printf("input ip address\n");
	char *name = (char*)malloc(sizeof(char)*15);
	//name = "127.0.0.1";
	scanf("%s",name);
	SetName(name);
	printf("input port number\n");
	int port;//=15000;
	scanf("%d",&port);
	SetPort(port);

    text = (char*)malloc(sizeof(char)*n);
	Init();
	printf("0 - for exit!\n");
    clientdata *d;
    d->numberclient = 0;
    pthread_t threadsend,threadreceive;
    pthread_create(&threadreceive,NULL,r,(void*)d);
    pthread_create(&threadsend,NULL,s,(void*)d);
	Close();
	free(name);
	free(text);
    return 0;
}