void NetworkManager::GameRun()
{
	PacketType type;

	Network::GameStartData gameStartData;
	puts("게임 시작 대기중");
	network.WaitForStart(&gameStartData);
	wprintf_s(L"매칭되었습니다. 상대방 이름: %s, 학번: %d\n", gameStartData.oppositionName, gameStartData.oppositionStudentID);

	bool allOver = false;

	while (!allOver)
	{
		
		GameInit();
		ShipSetting();

		try
		{
			GameStart();
			network.GetPacketType(&type);

			if (type == PKT_SC_NEXT_GAME)
			{
				puts("다음 게임을 준비해주세요.");
				
			}
			else if (type == PKT_SC_ALL_OVER)
			{
				Network::FinalResultData finalresult;
				finalresult = network.GetFinalResult();
				puts("모두 종료");
				printf_s("승리 횟수: %d, 평균 턴 수: %.1f", finalresult.winCount, finalresult.avgTurns);

				allOver = true;
			}
			else
			{
				throw Network::UNEXPECTED_PACKET;
			}
		}
		catch (Network::Exception ex)
		{
			switch (ex)
			{
			case Network::NETWORK_ERROR:
				puts("네트워크에 문제가 발생했습니다.");
				break;
			case Network::SERVER_CLOSED:
				puts("서버와의 연결이 끊어졌습니다.");
				break;
			case Network::PARAMETER_ERROR:
				puts("함수의 인수가 잘못되었습니다.");
				break;
			case Network::UNEXPECTED_PACKET:
				puts("서버에서 잘못된 정보가 전송되었습니다.");
				break;
			default:
				break;
			}
		}
		
	}
}

//.........这里部分代码省略.........
				throw err_code;
			for (n = 0; n < num_comps; n++)
			{
				io_byte *src = line + n; // Points to first sample of component n
				float *dst = input_comps[n].buf + r * input_comps[n].stride;
				for (int c = 0; c < width; c++, src += num_comps)
					dst[c] = (float)*src; // The cast to type "float" is not
						  // strictly required here, since bytes can always be
						  // converted to floats without any loss of information.
			}
		}
		delete[] line;
		bmp_in__close(&in);

		// Allocate storage for the filtered output
		my_aligned_image_comp *output_comps =
			new my_aligned_image_comp[num_comps];

		for (n = 0; n < num_comps; n++) {
			output_comps[n].init(out_size, out_size, 0); // Don't need a border for output
		}

		  // Process the image, all in floating point (easy)
		for (n = 0; n < num_comps; n++) {
			input_comps[n].perform_boundary_extension();
		}

		for (int k = 0; k < num_comps; ++k)
			for (int i = -half_outsize; i < half_outsize; ++i)
				for (int j = -half_outsize; j < half_outsize; ++j) {
					output_comps[k].buf[(i+ half_outsize) * output_comps[k].stride + (j+ half_outsize)]
						= input_comps[k].buf[i * input_comps[k].stride + j 
						+ location_x + location_y * input_comps[k].stride];
				}

		for (n = 0; n < num_comps; n++) {
			output_comps[n].mean_substract();
			output_comps[n].hanning_window();
		}

		
		// Write the image back out again
		bmp_out out;
		io_byte *out_line = new io_byte[out_size*num_comps];
		if ((err_code = bmp_out__open(&out, argv[2], out_size, out_size, num_comps)) != 0)
			throw err_code;
		for (r = out_size - 1; r >= 0; r--)
		{ // "r" holds the true row index we are writing, since the image is
		  // written upside down in BMP files.
			for (n = 0; n < num_comps; n++)
			{
				io_byte *dst = out_line + n; // Points to first sample of component n
				float *src = output_comps[n].buf + r * output_comps[n].stride;
				for (int c = 0; c < out_size; c++, dst += num_comps) {
					
					if (src[c] > 255) {
						src[c] = 255;
					}
					else if (src[c] < 0) {
						src[c] = 0;
					}
						
					*dst = (io_byte)src[c];
				}
			}
			bmp_out__put_line(&out, out_line);
		}
		bmp_out__close(&out);
		delete[]out_line;
		delete[] input_comps;
		delete[] output_comps;

		clock_t end_time = clock();
		float elaps = ((float)(end_time - start_time)) / CLOCKS_PER_SEC;
		printf_s("The runtime is %f seconds!\n\r", elaps);
		system("Pause");

	}
	catch (int exc) {
		if (exc == IO_ERR_NO_FILE)
			fprintf(stderr, "Cannot open supplied input or output file.\n");
		else if (exc == IO_ERR_FILE_HEADER)
			fprintf(stderr, "Error encountered while parsing BMP file header.\n");
		else if (exc == IO_ERR_UNSUPPORTED)
			fprintf(stderr, "Input uses an unsupported BMP file format.\n  Current "
				"simple example supports only 8-bit and 24-bit data.\n");
		else if (exc == IO_ERR_FILE_TRUNC)
			fprintf(stderr, "Input or output file truncated unexpectedly.\n");
		else if (exc == IO_ERR_FILE_NOT_OPEN)
			fprintf(stderr, "Trying to access a file which is not open!(?)\n");
		else if (exc == X_ECCESS)
			fprintf(stderr, "The given location eccess x dimension!\n");
		else if (exc == Y_ECCESS)
			fprintf(stderr, "The given location eccess y dimension!\n");
		else if (exc == NOT_A_EVEN_NUMBER)
			fprintf(stderr, "The given output dimension is not a odd number!\n");
		return -1;
	}
	return 0;
}

int main() {
	TList *list = new TList();
	printf_s("list.First() = %s\n", list->First());
	printf_s("list.Pop() = %s\n", list->Pop());

	list->Push("Hola");
	printf_s("Pushed \"Hola\"!\n");
	list->Push("Holita");
	printf_s("Pushed \"Holita\"!\n");
	list->Push("Que tal?");
	printf_s("Pushed \"Que tal?\"!\n");

	printf_s("list.Next() = %s\n", list->Next());
	printf_s("list.Next() = %s\n", list->Next());
	printf_s("list.Next() = %s\n", list->Next());
	printf_s("list.Next() = %s\n", list->Next());

	printf_s("list.First() = %s\n", list->First());
	printf_s("list.Pop() = %s\n", list->Pop());
	printf_s("list.First() = %s\n", list->First());

	list->Push("Hola");

	list->Reset();
	printf_s("list reset!\n");

	printf_s("list.First() = %s\n", list->First());
	printf_s("list.Next() = %s\n", list->Next());

	delete list;

	getchar();
}

bool GameInterface::GameStartOrReset()
{
	bool startOrReset = true;
	int gotoX = (m_MapSize + 3) * 4 + 4;
	int gotoY = 7;
	SetColor(BLACK, GREEN);
	SetCursorPosition(gotoX + 2, gotoY + 12);
	printf_s("                  \n");
	SetCursorPosition(gotoX + 2, gotoY + 13);
	printf_s("    Start Game    \n");
	SetCursorPosition(gotoX + 2, gotoY + 14);
	printf_s("                  \n");
	SetColor(BLACK, WHITE);
	SetCursorPosition(gotoX + 2, gotoY + 17);
	printf_s("                  \n");
	SetCursorPosition(gotoX + 2, gotoY + 18);
	printf_s("       Reset      \n");
	SetCursorPosition(gotoX + 2, gotoY + 19);
	printf_s("                  ");
	while (true)
	{
		int keyinput;
		keyinput = _getch();
		if (keyinput == -32)
		{
			keyinput = _getch();
		}
		if (keyinput == KEY_DOWN && startOrReset == true)
		{
			SetColor(BLACK, WHITE);
			SetCursorPosition(gotoX + 2, gotoY + 12);
			printf_s("                  \n");
			SetCursorPosition(gotoX + 2, gotoY + 13);
			printf_s("    Start Game    \n");
			SetCursorPosition(gotoX + 2, gotoY + 14);
			printf_s("                  \n");
			SetColor(BLACK, DARK_RED);
			SetCursorPosition(gotoX + 2, gotoY + 17);
			printf_s("                  \n");
			SetCursorPosition(gotoX + 2, gotoY + 18);
			printf_s("       Reset      \n");
			SetCursorPosition(gotoX + 2, gotoY + 19);
			printf_s("                  ");
			startOrReset = false; //Reset
		}
		else if (keyinput == KEY_UP && startOrReset == false)
		{
			SetColor(BLACK, GREEN);
			SetCursorPosition(gotoX + 2, gotoY + 12);
			printf_s("                  \n");
			SetCursorPosition(gotoX + 2, gotoY + 13);
			printf_s("    Start Game    \n");
			SetCursorPosition(gotoX + 2, gotoY + 14);
			printf_s("                  \n");
			SetColor(BLACK, WHITE);
			SetCursorPosition(gotoX + 2, gotoY + 17);
			printf_s("                  \n");
			SetCursorPosition(gotoX + 2, gotoY + 18);
			printf_s("       Reset      \n");
			SetCursorPosition(gotoX + 2, gotoY + 19);
			printf_s("                  ");
			startOrReset = true; //Start
		}
		else if (keyinput == ENTER)
		{
			break;
		}
	}
	SetColor(WHITE, BLACK);
	return startOrReset;
}

// SET METHODS //
void Card::SetRank(int rank)
{
    // Set m_iFaceValue based upon "rank", and RANK as well. (A == 1 ... K == 13)
    switch (rank)
    {
    case 1:
        m_iFaceValue = rank;
        m_eRank = RANK::ACE;
        break;
    case 2:
        m_iFaceValue = rank;
        m_eRank = RANK::TWO;
        break;
    case 3:
        m_iFaceValue = rank;
        m_eRank = RANK::THREE;
        break;
    case 4:
        m_iFaceValue = rank;
        m_eRank = RANK::FOUR;
        break;
    case 5:
        m_iFaceValue = rank;
        m_eRank = RANK::FIVE;
        break;
    case 6:
        m_iFaceValue = rank;
        m_eRank = RANK::SIX;
        break;
    case 7:
        m_iFaceValue = rank;
        m_eRank = RANK::SEVEN;
        break;
    case 8:
        m_iFaceValue = rank;
        m_eRank = RANK::EIGHT;
        break;
    case 9:
        m_iFaceValue = rank;
        m_eRank = RANK::NINE;
        break;
    case 10:
        m_iFaceValue = rank;
        m_eRank = RANK::TEN;
        break;
    case 11:
        m_iFaceValue = rank;
        m_eRank = RANK::JACK;
        break;
    case 12:
        m_iFaceValue = rank;
        m_eRank = RANK::QUEEN;
        break;
    case 13:
        m_iFaceValue = rank;
        m_eRank = RANK::KING;
        break;
    default:
        m_iFaceValue = 1;
        m_eRank = RANK::ACE;
        // Throw a message here stating we did not get the appropriate card set up correctly
        printf_s("Card's RANK was not set correctly, rank VALUE: %d", rank);
        break;
    };
}

int GameInterface::MenuSelect(int menuSize, int gotoX, int gotoY, int currentY, GameStatus gameStatus)
{
	int menuSelector = 0;
	bool okToStart = false;
	int sumShips;
	while (true)
	{
		int keyinput;
		keyinput = _getch();
		if (keyinput == -32)
		{
			keyinput = _getch();
		}
		if (keyinput == KEY_DOWN)
		{
			if (gameStatus == SELECT_PLAYER || gameStatus == SET_SHIP)
			{
				if (menuSelector >= 0 && menuSelector < menuSize - 1)
				{
					SetCursorPosition(gotoX, currentY);
					printf_s("  ");
					currentY += 3;
					menuSelector += 1;
					SetCursorPosition(gotoX, currentY);
					printf_s("¢º");
				}
			}
			else if (gameStatus == SELECT_MAP_SHIP)
			{
				if (menuSelector >= 0 && menuSelector < menuSize - 2)
				{
					SetCursorPosition(gotoX, currentY);
					printf_s("  ");
					currentY += 3;
					menuSelector += 1;
					SetCursorPosition(gotoX, currentY);
					printf_s("¢º");
				}
				else if (menuSelector == menuSize - 2)
				{
					sumShips = GetSumShip();
					SetCursorPosition(gotoX, currentY);
					printf_s("  ");
					currentY += 3;
					menuSelector += 1;
					if (sumShips == 0)
					{
						okToStart = false;
						SetColor(BLACK, DARK_RED);
						SetCursorPosition(gotoX + 18, gotoY + 20);
						printf_s("                   \n");
						SetCursorPosition(gotoX + 18, gotoY + 21);
						printf_s("      No Ship      \n");
						SetCursorPosition(gotoX + 18, gotoY + 22);
						printf_s("                   ");
					}
					else if (CheckEnoughSize() == false)
					{
						okToStart = false;
						SetColor(BLACK, DARK_RED);
						SetCursorPosition(gotoX + 18, gotoY + 20);
						printf_s("                   \n");
						SetCursorPosition(gotoX + 18, gotoY + 21);
						printf_s("   Too Many Ships  \n");
						SetCursorPosition(gotoX + 18, gotoY + 22);
						printf_s("                   ");
					}
					else
					{
						okToStart = true;
						SetColor(BLACK, GREEN);
						SetCursorPosition(gotoX + 18, gotoY + 20);
						printf_s("                   \n");
						SetCursorPosition(gotoX + 18, gotoY + 21);
						printf_s("      N E X T      \n");
						SetCursorPosition(gotoX + 18, gotoY + 22);
						printf_s("                   ");
					}
				}
			}
		}
		else if (keyinput == KEY_UP)
		{
			if (gameStatus == SELECT_PLAYER || gameStatus == SET_SHIP)
			{
				if (menuSelector >= 1 && menuSelector < menuSize)
				{
					SetCursorPosition(gotoX, currentY);
					printf_s("  ");
					currentY -= 3;
					menuSelector -= 1;
					SetCursorPosition(gotoX, currentY);
					printf_s("¢º");
				}
			}
			else if (gameStatus == SELECT_MAP_SHIP)
			{
				if (menuSelector >= 1 && menuSelector < menuSize - 1)
				{
					SetCursorPosition(gotoX, currentY);
//.........这里部分代码省略.........

void TurnstileGate::Unlock()
{
	setState(unlocked);
	printf_s("Unlocked\n\n");
}

void TurnstileGate::Thankyou()
{
	printf_s("Thanks!\n\n");
}

void CClientUdpSocket::Run()
{
	int nPacketCount = 1;
	m_blRun = true;
	SOCKET sckClient;
	SOCKET sckServer;

	//此部分为兼容Lua参数而设计
	//为了减少不必要的new和delete操作，所以参数在这里先声明好
	_ParamData* pSendParam1   = NULL;
	_ParamData* pSendParam2   = NULL;
	_ParamData* pSendParam3   = NULL;
	_ParamData* pSendParam4   = NULL;
	_ParamData* pSendParamOut = NULL;
	_ParamData* pRecvParam1   = NULL;
	_ParamData* pRecvParam2   = NULL;
	_ParamData* pRecvParam3   = NULL;
	_ParamData* pRecvParam4   = NULL;
	_ParamData* pRecvParamOut = NULL;

	int nLuaBufferMaxLength = m_pSocket_Info->m_pLogic->GetSendLength();

	if(m_pSocket_Info == NULL || m_pSocket_State_Info == NULL)
	{
		m_blRun = false;
		return;
	}

	//如果是高级模式
	if(m_pSocket_Info->m_blLuaAdvance == true)
	{
		m_objLuaFn.InitClass();

		bool blState = m_objLuaFn.LoadLuaFile(m_pSocket_Info->m_szLuaFileName);
		if(false == blState)
		{
			printf_s("[Main]Open Lua file error.\n");
			return;
		}

		//初始化所有要使用的Lua参数
		pSendParam1   = new _ParamData();
		pSendParam2   = new _ParamData();
		pSendParam3   = new _ParamData();
		pSendParam4   = new _ParamData();
		pSendParamOut = new _ParamData();
		pRecvParam1   = new _ParamData();
		pRecvParam2   = new _ParamData();
		pRecvParam3   = new _ParamData();
		pRecvParam4   = new _ParamData();
		pRecvParamOut = new _ParamData(); 

	}

	//看看是否是长连接，如果是长连接，则只处理一次。
	bool blIsConnect = false;

	//socket创建的准备工作
	struct sockaddr_in svrsockaddr;

	memset(&svrsockaddr, 0, sizeof(SOCKADDR_IN));
	svrsockaddr.sin_family = AF_INET;
	svrsockaddr.sin_port   = htons(m_pSocket_Info->m_nPort);
	svrsockaddr.sin_addr.S_un.S_addr = inet_addr(m_pSocket_Info->m_szSerevrIP);

	sckClient = socket(AF_INET, SOCK_DGRAM, 0);

	DWORD TimeOut = (DWORD)m_pSocket_Info->m_nRecvTimeout;
	::setsockopt(sckClient, SOL_SOCKET, SO_RCVTIMEO, (char *)&TimeOut, sizeof(TimeOut));

	//设置接收监听端口
	sckServer = socket(AF_INET, SOCK_DGRAM, 0);

	struct sockaddr_in clientsockaddr;
	memset(&clientsockaddr, 0, sizeof(SOCKADDR_IN));
	clientsockaddr.sin_family = AF_INET;
	clientsockaddr.sin_port   = htons(m_pSocket_Info->m_nUdpClientPort);
	clientsockaddr.sin_addr.S_un.S_addr = inet_addr(m_pSocket_Info->m_szSerevrIP);

	bind(sckServer, (SOCKADDR *) &clientsockaddr, sizeof(clientsockaddr));

	//发送次数
	int nSendIndex = 0;

	while(m_blRun)
	{
		unsigned int tBegin = (unsigned int)GetTickCount();
		if(m_pSocket_Info->m_nSendCount != 0 && m_pSocket_State_Info->m_nSuccessSend >= m_pSocket_Info->m_nSendCount)
		{
			//发送指定数目的数据包完成
			break;
		}

		//查看是否开启高级模式
		if(m_pSocket_Info->m_blLuaAdvance == true)
		{
			//重置缓冲最大长度
			m_pSocket_Info->m_pLogic->SetMaxSendLength(nLuaBufferMaxLength);

			//开始调用Lua脚本，去组织数据块
//.........这里部分代码省略.........

void NPC::Dead()
{
	printf_s("NPC is Dead!! \n");
}

// 初始化语音识别
HRESULT ThisApp::init_speech_recognizer(){
    HRESULT hr = S_OK;
    // 创建语音输入流
    if (SUCCEEDED(hr)){
        hr = CoCreateInstance(CLSID_SpStream, nullptr, CLSCTX_INPROC_SERVER, __uuidof(ISpStream), (void**)&m_pSpeechStream);;
    }
    // 与我们的Kinect语音输入相连接
    if (SUCCEEDED(hr)){
        WAVEFORMATEX wft = {
            WAVE_FORMAT_PCM, // PCM编码
            1, // 单声道
            16000,  // 采样率为16KHz
            32000, // 每分钟数据流 = 采样率 * 对齐
            2, // 对齐 : 单声道 * 样本深度 = 2byte
            16, // 样本深度 16BIT
            0 // 额外数据
        };
        // 设置状态
        hr = m_pSpeechStream->SetBaseStream(m_p16BitPCMAudioStream, SPDFID_WaveFormatEx, &wft);
    }
    // 创建语音识别对象
    if (SUCCEEDED(hr)){
        ISpObjectToken *pEngineToken = nullptr;
        // 创建语言识别器
        hr = CoCreateInstance(CLSID_SpInprocRecognizer, nullptr, CLSCTX_INPROC_SERVER, __uuidof(ISpRecognizer), (void**)&m_pSpeechRecognizer);
        if (SUCCEEDED(hr)) {
            // 连接我们创建的语音输入流对象
            m_pSpeechRecognizer->SetInput(m_pSpeechStream, TRUE);
            // 创建待识别语言 这里选择大陆汉语(zh-cn) 
            // 目前没有Kinect的汉语语音识别包 有的话可以设置"language=804;Kinect=Ture"
            hr = SpFindBestToken(SPCAT_RECOGNIZERS, L"Language=804", nullptr, &pEngineToken);
            if (SUCCEEDED(hr)) {
                // 设置待识别语言
                m_pSpeechRecognizer->SetRecognizer(pEngineToken);
                // 创建语音识别上下文
                hr = m_pSpeechRecognizer->CreateRecoContext(&m_pSpeechContext);
                // 适应性 ON! 防止因长时间的处理而导致识别能力的退化
                if (SUCCEEDED(hr))  {
                    hr = m_pSpeechRecognizer->SetPropertyNum(L"AdaptationOn", 0);
                }
            }
        }
        SafeRelease(pEngineToken);
    }
    // 创建语法
    if (SUCCEEDED(hr)){
        hr = m_pSpeechContext->CreateGrammar(1, &m_pSpeechGrammar);
    }
    // 加载静态SRGS语法文件
    if (SUCCEEDED(hr)){
        hr = m_pSpeechGrammar->LoadCmdFromFile(s_GrammarFileName, SPLO_STATIC);
    }
    // 激活语法规则
    if (SUCCEEDED(hr)){
        hr = m_pSpeechGrammar->SetRuleState(nullptr, nullptr, SPRS_ACTIVE);
    }
    // 设置识别器一直读取数据
    if (SUCCEEDED(hr)){
        hr = m_pSpeechRecognizer->SetRecoState(SPRST_ACTIVE_ALWAYS);
    }
    // 设置对识别事件感兴趣
    if (SUCCEEDED(hr)){
        hr = m_pSpeechContext->SetInterest(SPFEI(SPEI_RECOGNITION), SPFEI(SPEI_RECOGNITION));
    }
    // 保证语音识别处于激活状态
    if (SUCCEEDED(hr)){
        hr = m_pSpeechContext->Resume(0);
    }
    // 获取识别事件
    if (SUCCEEDED(hr)){
        m_p16BitPCMAudioStream->SetSpeechState(TRUE);
        m_hSpeechEvent = m_pSpeechContext->GetNotifyEventHandle();
		printf_s("init_speech_recognizer succeeded\n");
    }
#ifdef _DEBUG
    else
        printf_s("init_speech_recognizer failed\n");
#endif
    return hr;
}

void NetworkManager::GameStart()
{
	PacketType type;
	ErrorType error;
	bool gameOver = false;

	Position attackpos;
	Position hitpos;

	while (!gameOver)
	{
		error = network.GetPacketType(&type);

		switch (type)
		{
		case PKT_SC_ERROR:
			if (error == ET_OPPOSITION_DISCONNECTED)
				puts("상대방의 접속이 끊어졌습니다.");
			else
				puts("알 수 없는 에러입니다.");
			return;
			break;
		case PKT_SC_MY_TURN:
		{
			while (true)
			{
				if (m_player->GetType() == Ai)
				{
					AI* ai = (AI*)m_player;
					attackpos = ai->AttackShip();
				}
				else
				{
					attackpos = m_player->AttackShip();
				}

				printf_s("%c%c\n", attackpos.x, attackpos.y);

				error = network.SubmitAttack(PositionToCoord(attackpos));

				if (error == ET_INVALID_ATTACK)
					puts("유효하지 않은 공격 위치입니다.");
				else
					break;
			}
		}
			break;
		case PKT_SC_ATTACK_RESULT:
		{
			Network::AttackResultData result;
			result = network.GetAttackResult();
			if (result.isMine)
			{
				puts("공격 결과:");

				printf_s("%c%c ", result.pos.mX + 'a', result.pos.mY + '1');

				switch (result.attackResult)
				{
				case AR_DESTROY_AIRCRAFT:
					printf_s("Result: DESTROY_AIRCRAFT\n");
					break;
				case AR_DESTROY_BATTLESHIP:
					printf_s("Result: DESTROY_BATTLESHIP\n");
					break;
				case AR_DESTROY_CRUISER:
					printf_s("Result: DESTROY_CRUISER\n");
					break;
				case AR_DESTROY_DESTROYER:
					printf_s("Result: DESTROY_DESTROYER\n");
					break;
				case AR_HIT:
					printf_s("Result: HIT");
					break;
				case AR_MISS:
					printf_s("Result: MISS");
					break;

				}


				if (m_player->GetType() == Ai)
				{
					AI* ai = (AI*)m_player;
					ai->TakeAttackResult(attackpos, result.attackResult);
				}
				else
				{
					m_player->TakeAttackResult(attackpos, result.attackResult);
				}

			}
			else
			{
				puts("피격 결과:");
				hitpos.x = result.pos.mX + 'a';
				hitpos.y = result.pos.mY + '1';

				m_player->HitCheck(hitpos);
				printf_s("%c%c", hitpos.x, hitpos.y);
//.........这里部分代码省略.........

int main(int argc, char *argv[])
{
	Win32LoadOpenCv();
	
	CvMat *imageLeft = OpenCvImreadM("images/obstacles_0stereo.jpg", CV_LOAD_IMAGE_GRAYSCALE);
	CvMat *imageRight = OpenCvImreadM("images/obstacles_10stereo.jpg", CV_LOAD_IMAGE_GRAYSCALE);
	
	if((imageLeft == 0) || (imageRight == 0))
	{
		printf_s("One or more images failed to load \n");
		return -1;
	}
	
	CvMat *imageDisparity16S = OpenCvCreateMat(imageLeft->rows, imageLeft->cols,
		CV_16S); // CvMat{imageLeft->rows, CV_16S};
	CvMat *imageDisparity8U = OpenCvCreateMat(imageLeft->rows, imageLeft->cols,
		CV_8UC1); // CvMat(imageLeft->rows, CV_8UC1);
	
	int32 disparities = 112;
	CvStereoBMState *stereoBMState = OpenCvCreateStereoBMState(CV_STEREO_BM_BASIC,
		disparities);
	stereoBMState->SADWindowSize = 9;
	stereoBMState->preFilterSize = 5;
	stereoBMState->preFilterCap = 61;
	stereoBMState->minDisparity = -39;
	stereoBMState->textureThreshold = 507;
	stereoBMState->uniquenessRatio = 0;
	stereoBMState->speckleWindowSize = 0;
	stereoBMState->speckleRange = 8;
	stereoBMState->disp12MaxDiff = 1;
	
	for(int i = 1;
		i < 4;
		i = i + 2)
	{
		OpenCvSmooth(imageLeft, imageLeft, CV_BLUR, i, i, 3, 3);
	}
	for(int i = 1;
		i < 4;
		i = i + 2)
	{
		OpenCvSmooth(imageRight, imageRight, CV_BLUR, i, i, 3, 3);
	}
	
	OpenCvFindStereoCorrespondenceBM(imageLeft, imageRight,
			imageDisparity16S, stereoBMState);
		
	double minValue;
	double maxValue;
	OpenCvMinMaxLoc(imageDisparity16S, &minValue, &maxValue, 0, 0, 0);
	
	printf_s("Min disparity: %f - Max disparity: %f \n",
		minValue, maxValue);
		
	OpenCvConvertScale(imageDisparity16S, imageDisparity8U,
		255.0/(maxValue - minValue), 0);
		
	// OpenCvNamedWindow(g_WindowName, CV_WINDOW_AUTOSIZE);
	// OpenCvShowImage(g_WindowName, imageDisparity8U);
	
	OpenCvSaveImage("../matlab/disparityMap.bmp", imageDisparity8U, 0);
	
	OpenCvWaitKey(0);
	
	OpenCvReleaseStereoBMState(&stereoBMState);
	
	return 0;
}

int main(int argc, char* argv[])
{
	int infoMago = 0xFFA82000;
	int opcion = 0;
	unsigned int balas = 0;

	do {
		printf_s("MENU DEL PERSONAJE:\n");

		printf_s("Elija una de las siguientes opciones\n");
		printf_s("1. Mostrar número de balas\n");
		printf_s("2. Añadir balas\n");
		printf_s("3. Comprobar si tienes balas infinitas\n");
		printf_s("4. Activar las balas infinitas\n");
		printf_s("5. Salir\n\n");

		scanf_s("%i", &opcion);
		printf_s("\n");


		switch (opcion) {
		case 1:
			printf_s("Balas en el inventario: %d\n", balasInventario(infoMago));
			printf_s("\n");
			break;
		case 2:
			printf_s("Número de balas actual: %u\n", balasInventario(infoMago));
			printf_s("¿Cuántas balas quieres añadir?: ");
			scanf_s("%i", &balas);
			printf_s("\n");
			if (balas > 255) {
				printf_s("El máximo de balas que puedes llevar es 255\n");
			}
			printf_s("Balas en el inventario: %u\n", anadirBalas(infoMago, balas));
			printf_s("\n");
			break;
		case 3:
			if (comprobarBalasInfinitas(infoMago)) {
				printf_s("Tienes balas infinitas\n");
				printf_s("\n");
			}
			else {
				printf_s("No tienes balas infinitas\n");
				printf_s("\n");
			}
			break;
		case 4:
			if (activarBalasInfinitas(infoMago)) {
				printf_s("Ya tienes balas infinitas\n");
				printf_s("\n");
			}
			else {
				printf_s("No tienes balas infinitas\n");
				printf_s("\n");
			}
			break;
		case 5:
			break;
		}
	} while (opcion != 5);
}

void GameInterface::AttachInterface(GameStatus gameStatus)
{
	int gotoX;
	int gotoY;
	int currentY;
	int menuSelector = 0;
	switch (gameStatus)
	{
	case TITLE:
		gotoX = 0;
		gotoY = 10;
		while (!_kbhit())
		{
			Sleep(600);
			SetCursorPosition(gotoX, gotoY);
			printf_s("\t\t\t     PRESS ENTER KEY TO START      \t\t\t");
			Sleep(1000);
			SetCursorPosition(gotoX, gotoY);
			printf_s("                                                                            ");
		}
		getchar();
		break;
	case SELECT_PLAYER:
		gotoX = 22;
		gotoY = 9;
		currentY = gotoY + 6;
		SetColor(BLACK, WHITE);
		SetCursorPosition(gotoX, gotoY);
		printf_s("                  \n");
		SetCursorPosition(gotoX, gotoY + 1);
		printf_s("   PLAYER SELECT  \n");
		SetCursorPosition(gotoX, gotoY + 2);
		printf_s("                  ");
		SetColor(WHITE, BLACK);
		SetCursorPosition(gotoX + 7, gotoY + 6);
		printf_s("VS Friend");
		SetCursorPosition(gotoX + 7, gotoY + 9);
		printf_s("VS AI");
		SetCursorPosition(gotoX + 7, gotoY + 12);
		printf_s("VS Network");
		SetCursorPosition(gotoX - 1, currentY);
		printf_s("¢º");
		menuSelector = MenuSelect(3, gotoX, gotoY, currentY, gameStatus);
		if (menuSelector == 0)
		{
			m_GameType = PVP_PLAY;
		}
		else if (menuSelector == 1)
		{
			m_GameType = AI_PLAY;
		}
		else if (menuSelector == 2)
		{
			m_GameType = NET_PLAY;
		}
		break;
	case SELECT_MAP_SHIP:
		gotoX = 4;
		gotoY = 9;
		currentY = gotoY + 5;
		SetColor(BLACK, WHITE);
		SetCursorPosition(gotoX + 18, gotoY);
		printf_s("                  \n");
		SetCursorPosition(gotoX + 18, gotoY + 1);
		printf_s("    SHIP SELECT   \n");
		SetCursorPosition(gotoX + 18, gotoY + 2);
		printf_s("                  ");
		SetColor(WHITE, BLACK);
		SetCursorPosition(gotoX + 6, gotoY + 5);
		printf_s("Map size");
		SetCursorPosition(gotoX + 6, gotoY + 8);
		printf_s("Aircraft Carrier");
		SetCursorPosition(gotoX + 6, gotoY + 11);
		printf_s("Battleship");
		SetCursorPosition(gotoX + 6, gotoY + 14);
		printf_s("Cruiser");
		SetCursorPosition(gotoX + 6, gotoY + 17);
		printf_s("Destroyer");
		SetColor(BLACK, WHITE);
		SetCursorPosition(gotoX + 18, gotoY + 20);
		printf_s("                   \n");
		SetCursorPosition(gotoX + 18, gotoY + 21);
		printf_s("      N E X T      \n");
		SetCursorPosition(gotoX + 18, gotoY + 22);
		printf_s("                   ");
		SetColor(WHITE, BLACK);
		SetCursorPosition(gotoX + 40, gotoY + 5);
		printf_s("¢¸ %d*%d ¢º", m_MapSize, m_MapSize);
		SetCursorPosition(gotoX + 40, gotoY + 8);
		printf_s("¢¸  %d  ¢º", m_NumShip[0]);
		SetCursorPosition(gotoX + 40, gotoY + 11);
		printf_s("¢¸  %d  ¢º", m_NumShip[1]);
		SetCursorPosition(gotoX + 40, gotoY + 14);
		printf_s("¢¸  %d  ¢º", m_NumShip[2]);
		SetCursorPosition(gotoX + 40, gotoY + 17);
		printf_s("¢¸  %d  ¢º", m_NumShip[3]);
		SetCursorPosition(gotoX, currentY);
		printf_s("¢º");
		menuSelector = MenuSelect(6, gotoX, gotoY, currentY, gameStatus);
		break;
//.........这里部分代码省略.........

unsigned int WINAPI IocpManager::IoWorkerThread(LPVOID lpParam)
{
	LThreadType = THREAD_IO_WORKER;
	LIoThreadId = reinterpret_cast<int>(lpParam);
	LTimer = new Timer;
	LLockOrderChecker = new LockOrderChecker(LIoThreadId);

	HANDLE hComletionPort = GIocpManager->GetComletionPort();

	while (true)
	{
		/// 타이머 작업은 항상 돌리고
		LTimer->DoTimerJob();

		/// IOCP 작업 돌리기
		DWORD dwTransferred = 0;
		OverlappedIOContext* context = nullptr;
		ULONG_PTR completionKey = 0;

		int ret = GetQueuedCompletionStatus(hComletionPort, &dwTransferred, (PULONG_PTR)&completionKey, (LPOVERLAPPED*)&context, GQCS_TIMEOUT);

		ClientSession* theClient = context ? context->mSessionObject : nullptr ;
		
		if (ret == 0 || dwTransferred == 0)
		{
			int gle = GetLastError();

			/// check time out first 
			if( gle == WAIT_TIMEOUT && context == nullptr )
					continue;
		
			if (context->mIoType == IO_RECV || context->mIoType == IO_SEND )
			{
				CRASH_ASSERT(nullptr != theClient);

				/// In most cases in here: ERROR_NETNAME_DELETED(64)

				theClient->DisconnectRequest(DR_COMPLETION_ERROR);

				DeleteIoContext(context);

				continue;
			}
		}

		CRASH_ASSERT(nullptr != theClient);
	
		bool completionOk = false;
		switch (context->mIoType)
		{
		case IO_DISCONNECT:
			theClient->DisconnectCompletion(static_cast<OverlappedDisconnectContext*>(context)->mDisconnectReason);
			completionOk = true;
			break;

		case IO_ACCEPT:
			theClient->AcceptCompletion();
			completionOk = true;
			break;

		case IO_RECV_ZERO:
			completionOk = PreReceiveCompletion(theClient, static_cast<OverlappedPreRecvContext*>(context), dwTransferred);
			break;

		case IO_SEND:
			completionOk = SendCompletion(theClient, static_cast<OverlappedSendContext*>(context), dwTransferred);
			break;

		case IO_RECV:
			completionOk = ReceiveCompletion(theClient, static_cast<OverlappedRecvContext*>(context), dwTransferred);
			break;

		default:
			printf_s("Unknown I/O Type: %d\n", context->mIoType);
			CRASH_ASSERT(false);
			break;
		}

		if ( !completionOk )
		{
			/// connection closing
			theClient->DisconnectRequest(DR_IO_REQUEST_ERROR);
		}

		DeleteIoContext(context);
	}

	return 0;
}

/* main:  register the interface, start listening for clients */
void __cdecl main(int argc, char * argv[])
{
    RPC_STATUS status;
    unsigned char * pszProtocolSequence = "ncacn_ip_tcp";
    unsigned char * pszSecurity         = NULL;
    unsigned char * pszEndpoint         = "8765";
    unsigned char * pszSpn              = NULL;	
    unsigned int    cMinCalls           = 1;
    unsigned int    cMaxCalls           = 20;
    unsigned int    fDontWait           = FALSE;

    int i;

    /* allow the user to override settings with command line switches */
    for (i = 1; i < argc; i++) {
        if ((*argv[i] == '-') || (*argv[i] == '/')) {
            switch (tolower(*(argv[i]+1))) {
            case 'p':  // protocol sequence
                pszProtocolSequence = argv[++i];
                break;
            case 'e':
                pszEndpoint = argv[++i];
                break;
            case 'a':
                pszSpn = argv[++i];
                break;
            case 'm':
                cMaxCalls = (unsigned int) atoi(argv[++i]);
                break;
            case 'n':
                cMinCalls = (unsigned int) atoi(argv[++i]);
                break;
            case 'f':
                fDontWait = (unsigned int) atoi(argv[++i]);
                break;
	  /* case 'i':
		if(!_stricmp(argv[++i],"No_Authenticate"))
			ifFlag = RPC_IF_ALLOW_CALLBACKS_WITH_NO_AUTH;
		break;*/

            case 'h':
            case '?':
            default:
                Usage(argv[0]);
            }
        }
        else
            Usage(argv[0]);
    }

    status = RpcServerUseProtseqEp(pszProtocolSequence,
                                   cMaxCalls,
                                   pszEndpoint,
                                   pszSecurity);  // Security descriptor
    printf_s("RpcServerUseProtseqEp returned 0x%x\n", status);
    if (status) {
        exit(status);
    }

    /* User did not specify spn, construct one. */
    if (pszSpn == NULL) {
        MakeSpn(&pszSpn);
    }

    /* Using Negotiate as security provider */
    status = RpcServerRegisterAuthInfo(pszSpn,
                                       RPC_C_AUTHN_GSS_NEGOTIATE,
                                       NULL,
                                       NULL);
	
    printf_s("RpcServerRegisterAuthInfo returned 0x%x\n", status);
    if (status) {
        exit(status);
    }	

    status = RpcServerRegisterIfEx(umarsh_ServerIfHandle,
		                           NULL,
		                           NULL,
		                           0,
		                           RPC_C_LISTEN_MAX_CALLS_DEFAULT,
		                           NULL );

    printf_s("Calling RpcServerListen\n");
    status = RpcServerListen(cMinCalls,
                             cMaxCalls,
                             fDontWait);
    printf_s("RpcServerListen returned: 0x%x\n", status);
    if (status) {
        exit(status);
    }

    if (fDontWait) {
        printf_s("Calling RpcMgmtWaitServerListen\n");
        status = RpcMgmtWaitServerListen();  //  wait operation
        printf_s("RpcMgmtWaitServerListen returned: 0x%x\n", status);
        if (status) {
            exit(status);
        }
    }
//.........这里部分代码省略.........

/**
 * Print out an array of integers with a new line.
 */
void println_s(int64_t* input, size_t input_size) {
	printf_s(input, input_size);
	printf("\n");
}

int main()
{
	int i, j, len, a, b;
	char *src = "6*(5+(2+3)*8+3)";
	char des[255];
	Stack S;

	S = createStack();
	if (S == NULL) {
		printf_s("Error\n");
		return 1;
	}

	i = len = 0;
	while (src[i++] != '\0')
		len++;

	/* 将中缀转换为后缀 */
	for (i = j = 0; i < len; i++) {
		if (isSymbol(src[i])) {
			if (src[i] != ')') {
				if (isEmpty(S))
					pushChar(src[i], S);
				else if (pricmp(src[i], topChar(S)) > 0)
					pushChar(src[i], S);                      
				else {
					while (!isEmpty(S) && pricmp(src[i], topChar(S)) <= 0) {
						des[j++] = topChar(S);
						pop(S);
					}
					pushChar(src[i], S);
				}
			}
			else if (src[i] == ')') {
				while (topChar(S) != '(' && !isEmpty(S)) {
					des[j++] = topChar(S);
					pop(S);
				}
				pop(S);
			}
		}
		else {
			des[j++] = src[i];
		}
	}
	/* 将栈里的剩余符号弹出 */
	while (!isEmpty(S)) {
		des[j++] = topChar(S);
		pop(S);
	}
	des[j--] = '\0';
	printf("%s\n", des);
	/* 转换结束 */
	
	/* 用后缀表达式完成计算 */
	i = len = 0;
	while (des[i++] != '\0')
		len++;

	for (i = 0; i < len; i++) {
		if (!isSymbol(des[i]))
			pushInt(des[i] - 48, S);
		else {
			a = topInt(S);
			pop(S);
			b = topInt(S);
			pop(S);
			//printf_s("\na=%d, b=%d\n", a, b);
			switch (des[i]) {
			case '+':
				pushInt(a + b, S);
				break;
			case '-':
				pushInt(a - b, S);
				break;
			case '*':
				pushInt(a*b, S);
				break;
			case '/':
				pushInt(a / b, S);
				break;
			}
		}
	}
	printf_s("Result=%d\n", topInt(S));
	return 0;
}

int main(void)
{
    ItemStruct *itemList = NULL;
    int slotCount = 0;
    char selection;
    int errorFlag = TRUE;
    int continueFlag = TRUE;
    char fileName[C_FILE_NAME_LENGTH] = "test.bin";

    printf_s("Welcome to the shopping list!\n");

    itemList = (ItemStruct*)malloc(sizeof(ItemStruct));

    do
    {
        if (itemList == NULL)
        {
            printf_s("\n");
            printf_s("*** Out of Memory! Program abort! ***\n");
            Sleep(1000);
            return 1;
        }
        printMeny();
        selection =