예제 #1
0
	void GUIWindow::postUpdate()
	{
		//Check size and positioning before drawing strech
		if (!checkBit(state, GUIRECT_SCALED))
			updateScale();
		if (!checkBit(state, GUIRECT_POSITIONED))
			updatePosition();

		strech->postUpdate();
		GUIRectangleContainer::postUpdate();
		header->postUpdate();
		exit->postUpdate();
	}
예제 #2
0
void System::getStandardProcessorExtensions() {
#if ! defined(G3D_OSX) || defined(G3D_OSX_INTEL)
    if (! m_hasCPUID) {
        return;
    }

    uint32 eaxreg = 0, ebxreg = 0, ecxreg = 0, features = 0;

    cpuid(CPUID_PROCESSOR_FEATURES, eaxreg, ebxreg, ecxreg, features);

#   define checkBit(var, bit)   ((var & (1 << bit)) ? true : false)

    m_hasRDTSC    = checkBit(features, 4);
    m_hasMMX      = checkBit(features, 23);
    m_hasSSE      = checkBit(features, 25);
    m_hasSSE2     = checkBit(features, 26);
    // Bit 28 is HTT; not checked by G3D

    m_hasSSE3     = checkBit(ecxreg, 0);

    if (m_highestCPUIDFunction >= CPUID_EXTENDED_FEATURES) {
        cpuid(CPUID_EXTENDED_FEATURES, eaxreg, ebxreg, ecxreg, features);
        m_hasAMDMMX = checkBit(features, 22);  // Only on AMD
        m_has3DNOW  = checkBit(features, 31);  // Only on AMD
        m_has3DNOW2 = checkBit(features, 30);  // Only on AMD
    } else {
        m_hasAMDMMX = false;
        m_has3DNOW  = false;
        m_has3DNOW2 = false;
    }

#   undef checkBit
#endif
}
예제 #3
0
void SAXParser::processElement()
{
	Element element;
	// C.3.3 If the optional component attributes is present, then the bit '1' (presence) is appended to the bit stream;
	// otherwise, the bit '0' (absence) is appended.
	bool hasAttributes = checkBit(_b, 2) != 0;
	
	// C.3.4 If the optional component namespace-attributes is present, it is encoded as described in the three
	// following subclauses.
	
	// C.3.4.1 The four bits '1110' (presence) and the two bits '00' (padding) are appended to the bit stream.
	// check for namespace attributes
	if((_b & Constants::ELEMENT_NAMESPACE_ATTRIBUTES_MASK) == Constants::ELEMENT_NAMESPACE_ATTRIBUTES_FLAG)
	{
		throw std::runtime_error("No namespace support yet");
	}

	// C.3.5 The value of the component qualified-name is encoded as described in C.18.
	getQualifiedNameOrIndex3(element._qualifiedName);
	
	if(hasAttributes) 
		processAttributes();

	_contentHandler->startElement(_vocab, element, _attributes);
	_attributes.clear();

	while(!_terminated) {
		_b = static_cast<unsigned char>(_stream->get());
		if(!checkBit(_b, 1)) { // 0 padding announcing element
			processElement();
		}
		else if((_b & Constants::TWO_BITS) == Constants::ELEMENT_CHARACTER_CHUNK)
		{
			processCharacterChunk();
		}
		else if (_b == Constants::TERMINATOR_SINGLE ||
				 _b == Constants::TERMINATOR_DOUBLE)
		{
			_terminated = true;
			_doubleTerminated = _b == Constants::TERMINATOR_DOUBLE;
		}
		else
			throw std::runtime_error("message.decodingEIIs");
	}
	_contentHandler->endElement(_vocab, element);
	
	_terminated = _doubleTerminated;
	_doubleTerminated = false;
}
예제 #4
0
파일: adjMatrix.cpp 프로젝트: meyersh/gimli
int unweightedUndirected::checkBit(int r, int c)
/* return the value (0 or 1) of the bit in row r and column c without 
   changing the values of any bits (including those being tested). */
{
   if (c > r)
      return checkBit(c, r);
   else if (c == r)
      return main_diagonal;
   else
      return (bool)(*matrix)[t(r)+c];
}
예제 #5
0
	int getStringAsInt(const std::string& string)
	{
		int8_t stringState = 0;
		int intValue = 0;
		for (unsigned i = 0; i < string.size(); i++)
		{
			if (string[i] >= '0' && string[i] <= '9')
			{//Add numerical value
				{
					intValue *= 10;
					intValue += int(string[i] - 48);
				}
			}
			else if (string[i] == '-')
			{
				if (checkBit(stringState, 1))
				{//Second '-' character, return
					return 0.0f;
				}
				enableBit(stringState, 1);//Negative
			}
			else if (string[i] == '.' || string[i] == ',')
			{
				if (checkBit(stringState, 2))
				{//Second ',/.' character, return
					return 0.0f;
				}
				enableBit(stringState, 2);//Begin decimal part
			}
			else
			{//Character is unknown
				return 0.0f;
			}
		}

		//negate if needed
		if (checkBit(stringState, 1))
			intValue *= -1;

		return intValue;
	}
예제 #6
0
파일: adjMatrix.cpp 프로젝트: meyersh/gimli
void unweightedUndirected::print()
/* should output the array one full row at a time of  0's and 1's.  Note 
   that both, including the triangular array, should be output as a sz x sz 
   array on the screen.  (It's okay if lines too long for the screen wrap.) */
{
   for (int row = 0; row < size; row++)
      {
      for (int col = 0; col < size; col++)
	 std::cout << checkBit(row, col) << " ";
      std::cout << std::endl;
      }
}
예제 #7
0
uint16_t analogRead(uint8_t ch)
{
	uint16_t value;

	ADMUX = adcSetting | ch; // Set the desired channel

	sbi(ADCSRA,ADSC); // Start conversion

	while(checkBit(ADCSRA,ADSC)); // Wait for conversion	

	value = ADCL;	value += ADCH << 8; // Read the result

	return value; // Return value
}
예제 #8
0
파일: ZEcc.c 프로젝트: fatestudio/ZMP
Node eccMul(BigNum k, Node P, BigNum a, BigNum b, BigNum p){
	int i;
	Node ret;
	initNode(&ret);

	u_int32_t num = checkBit(k, k.bits - 1);

	if(num == 1){
		ret = copyNode(P);
	}	// else ret = (0, 0)

	for(i = k.bits - 2; i >= 0; i--){
		ret = eccAdd(ret, ret, a, b, p);

		// get e[i]
		num = checkBit(k, i);
		if(num == 1){
			ret = eccAdd(ret, P, a, b, p);
		}
	}

	return ret;
}
예제 #9
0
void SAXParser::processDocument()
{
	_contentHandler->startDocument();
	processDocumentProperties();
	
	// Process children
	while(!_terminated)
	{
		_b = static_cast<unsigned char>(_stream->get());
		if(!checkBit(_b, 1)) { // 0 padding announcing element
			processElement();
		}
	}

	_contentHandler->endDocument();
}
예제 #10
0
///////////////////////
// IO SERVICE THREAD //
void Game::receiveHandlerTCP(const boost::system::error_code& error, std::size_t bytes)
{
	//Handle data sent by the server
	size_t offset = 0;//Byte offset from buffer begin
	do
	{
		offset += 1;
		switch (packet::PacketType(receiveBufferTCP[offset - 1]))
		{
		default:
		case packet::invalid:
			spehs::console::error(__FUNCTION__" invalid packet type!");
			break;
		case packet::enterID:
		{
			std::lock_guard<std::recursive_mutex> IDLockGuardMutex(idMutex);
			memcpy(&ID, &receiveBufferTCP[offset], sizeof(sizeof(ID)));
			offset += sizeof(CLIENT_ID_TYPE);
		}
		break;
		case packet::createObj:
		{
			std::lock_guard<std::recursive_mutex> objectLockGuardMutex(objectMutex);
			unsigned count;
			memcpy(&count, &receiveBufferTCP[offset], sizeof(unsigned));
			offset += sizeof(unsigned);
			for (unsigned i = 0; i < count; i++)
			{
				newObjects.push_back(ObjectData());
				memcpy(&newObjects.back(), &receiveBufferTCP[offset], sizeof(ObjectData));
				offset += sizeof(ObjectData);
			}
		}
			break;
		}
	} while (offset < bytes);


	//Start receiving again
	if (checkBit(state, GAME_EXIT_BIT))
		socketTCP.async_receive(
			boost::asio::buffer(receiveBufferTCP),
			boost::bind(&Game::receiveHandlerTCP,
			this, boost::asio::placeholders::error,
			boost::asio::placeholders::bytes_transferred));
}
예제 #11
0
void interrupt ISR(void)
{
    //Turn ON/OFF RC3 in order to indicate 
    //that an interrupt occured
    //useful for debugging
    if(checkBit(ShadowPortC,3)>0){
        SetBitReg(Reg_PORTC,3,LOW);
    }
    else{
        SetBitReg(Reg_PORTC,3,HIGH);
    }
    
    //UART interrupt
    if(RCIF && RCIE){
        UART_Interrupt();
        
        return;
    }
}
예제 #12
0
void SAXParser::processAttributes()
{
	do {
		_b = static_cast<unsigned char>(_stream->get());
		if (!checkBit(_b,1))
		{
			FI::Attribute attribute;
			getAttribute(attribute);
			_attributes.push_back(attribute);
		}
		else if (_b == Constants::TERMINATOR_SINGLE ||
				 _b == Constants::TERMINATOR_DOUBLE)
		{
			_terminated = true;
			_doubleTerminated = _b == Constants::TERMINATOR_DOUBLE;
		}
		else
			throw std::runtime_error("message.decodingAIIs");

	} while(!_terminated);

	_terminated = _doubleTerminated;
	_doubleTerminated = false;
}
예제 #13
0
	void GUIWindow::update()
	{

		//Clicking within window -> gaining focus
		//if (checkState(GUIRECT_ENABLED_BIT) && !isFocused() && isOpen() && inputManager->isKeyPressed(MOUSE_BUTTON_LEFT) && (strech->updateMouseHover() || getMouseHover()))
			//gainFocus();

		//Run update in all members
		GUIRectangleContainer::update();
		header->update();
		exit->update();
		strech->update();
		if (strech->getMouseHover())
		{
			enableBit(state, GUIRECT_MOUSE_HOVER);
			enableBit(state, GUIRECT_MOUSE_HOVER_CONTAINER);
		}

		////DRAGGING
		//Handle previous frame dragging
		if (checkState(GUIRECT_DRAGGING_BIT) && inputManager->isKeyDown(MOUSE_BUTTON_LEFT))
			translate(inputManager->getMouseMovementX(), inputManager->getMouseMovementY());
		//Set dragging boolean
		if (checkState(GUIRECT_ENABLED_BIT) && !checkState(GUIRECT_DRAGGING_BIT) && header->getMouseHover() && inputManager->isKeyPressed(MOUSE_BUTTON_LEFT))
			enableState(GUIRECT_DRAGGING_BIT);//Begin dragging
		else if (checkState(GUIRECT_DRAGGING_BIT) && !inputManager->isKeyDown(MOUSE_BUTTON_LEFT))
		{//Stop dragging

#ifdef DOCK_BORDER
			//Check docking
			if (inputManager->getMouseX() < DOCK_BORDER)
			{//Dock left
				setSize(minSize.x, applicationData->getWindowHeight() - upBorder - downBorder - header->getHeight() - 2 * strechWidth);
				setPositionLocal(strechWidth + leftBorder, strechWidth + downBorder);
			}
			else if (inputManager->getMouseX() > applicationData->getWindowWidth() - DOCK_BORDER)
			{//Dock right
				setSize(minSize.x, applicationData->getWindowHeight() - upBorder - downBorder - header->getWidth() - 2 * strechWidth);
				setPositionLocal(applicationData->getWindowWidth() - size.x - strechWidth - rightBorder, strechWidth + downBorder);
			}

			if (inputManager->getMouseY() < DOCK_BORDER)
			{//Dock down
				setSize(applicationData->getWindowWidth() - 2 * strechWidth - leftBorder - rightBorder, minSize.y);
				setPositionLocal(strechWidth + leftBorder, strechWidth + downBorder);
			}
			else if (inputManager->getMouseY() > applicationData->getWindowHeight() - DOCK_BORDER)
			{//Dock up
				setSize(applicationData->getWindowWidth() - 2 * strechWidth - leftBorder - rightBorder, minSize.y);
				setPositionLocal(strechWidth + leftBorder, applicationData->getWindowHeight() - header->getHeight() - strechWidth - size.y - upBorder);
			}
#endif

			limitWithinMainWindow();
			disableState(GUIRECT_DRAGGING_BIT);
		}

		////STRECHING
		//Handle previous frame strech
		if (checkState(GUIRECT_STRECHING_BIT) && inputManager->isKeyDown(MOUSE_BUTTON_LEFT))
		{
			//Take record of current dimensions
			float w = size.x;
			float h = size.y;
			bool breakFromStrech = false;

			//Check horizontal strech movement
			if (checkBit(strechState, STRECH_STATE_HORIZONTAL))
			{
				//Check if mouse has crossed over to the opposite side of the window -> break from strech
				if (checkBit(strechState, STRECH_STATE_W))
				{//Strech began from left side of the window
					if (inputManager->getMouseX() > getXGlobal() + size.x / 2.0f)
						breakFromStrech = true;
				}
				else
				{//Strech began from the right side of the window
					if (inputManager->getMouseX() < getXGlobal() + size.x / 2.0f)
						breakFromStrech = true;
				}

				//Strech window based on mouse movement
				if (!breakFromStrech)
				{
					if (inputManager->getMouseX() > position.x + size.x / 2.0f)
					{
						w += inputManager->getMouseMovementX();
					}
					else
					{
						w -= inputManager->getMouseMovementX();
						if (abs(size.x - minSize.x) > 0.01f)
							translate(inputManager->getMouseMovementX(), 0);
					}
				}
			}

			//Check vertical strech movement
			if (!breakFromStrech && checkBit(strechState, STRECH_STATE_VERTICAL))
			{
				//Check if mouse has crossed over to the opposite side of the window -> break from strech
				if (checkBit(strechState, STRECH_STATE_N))
				{//Strech began from upper side of the window
					if (inputManager->getMouseY() < getYGlobal() + size.y / 2.0f + header->getHeight() / 2.0f)
						breakFromStrech = true;
				}
				else
				{//Strech began from the lower side of the window
					if (inputManager->getMouseY() > getYGlobal() + size.y / 2.0f + header->getHeight() / 2.0f)
						breakFromStrech = true;
				}

				//Strech window based on mouse movement
				if (!breakFromStrech)
				{
					if (inputManager->getMouseY() > position.y + size.y / 2.0f)
					{
						h += inputManager->getMouseMovementY();
					}
					else
					{
						h -= inputManager->getMouseMovement().y;
						if (abs(size.y - minSize.y) > 0.01f)
						translate(0, inputManager->getMouseMovementY());
					}
				}
			}

			//Set size to the calculated dimensions
			setSize(w, h);

			//position within main application window
			limitWithinMainWindow();
		}

		//Handle strech state bit
		if (checkState(GUIRECT_ENABLED_BIT) &&
			!checkState(GUIRECT_STRECHING_BIT) &&
			inputManager->isKeyPressed(MOUSE_BUTTON_LEFT) &&
			mouseOverStrechArea())
		{//Begin streching

			////Define state variables
			enableState(GUIRECT_STRECHING_BIT);
			strechState = 0;
			//Horizontal
			if (inputManager->getMouseX() < getXGlobal() + size.x * STRECH_CORNER_PERCENTAGE)
			{
				//Enable horizontal streching
				enableBit(strechState, STRECH_STATE_HORIZONTAL);
				//Take record that the streching began from the western side of the window
				enableBit(strechState, STRECH_STATE_W);
			}
			else if (inputManager->getMouseX() > getXGlobal() + size.x * (1.0 - STRECH_CORNER_PERCENTAGE))
			{
				//Enable horizontal streching
				enableBit(strechState, STRECH_STATE_HORIZONTAL);
				//Take record that the streching began from the eastern side of the window
				enableBit(strechState, STRECH_STATE_E);
			}
			//Vertical
			if (inputManager->getMouseY() < getYGlobal() + size.y * STRECH_CORNER_PERCENTAGE)
			{
				//Enable vertical streching
				enableBit(strechState, STRECH_STATE_VERTICAL);
				//Take record that the streching began from the southern side of the window
				enableBit(strechState, STRECH_STATE_S);
			}
			else if (inputManager->getMouseY() > getYGlobal() + size.y * (1.0 - STRECH_CORNER_PERCENTAGE))
			{
				//Enable vertical streching
				enableBit(strechState, STRECH_STATE_VERTICAL);
				//Take record that the streching began from the northern side of the window
				enableBit(strechState, STRECH_STATE_N);
			}
		}
		else if (checkState(GUIRECT_STRECHING_BIT) &&
			(!checkState(GUIRECT_ENABLED_BIT) || !inputManager->isKeyDown(MOUSE_BUTTON_LEFT)))
		{//Conditions not met to continue streching, set to false
			disableState(GUIRECT_STRECHING_BIT);
			strechState = 0;
		}

		////Header double clicking
		//Timer decrease
		if (doubleClickTimer > 0)
			doubleClickTimer -= time::getDeltaTimeAsMilliseconds();
		//Check header double click
		if (checkState(GUIRECT_ENABLED_BIT) && inputManager->isKeyPressed(MOUSE_BUTTON_LEFT) && header->getMouseHover())
		{//Header has been clicked
			if (doubleClickTimer > 0)
			{//Header double click detected
				disableState(GUIRECT_DRAGGING_BIT);

				if (size == minSize)
				{//Set to full window

					//Set size according to application data's window dimensions
					setSize(applicationData->getWindowWidth() - rightBorder - leftBorder, applicationData->getWindowHeight() - upBorder - downBorder - header->getHeight());
					setPositionLocal(0, 0);

					//Position window so that it won't go out of the application window
					limitWithinMainWindow();
				}
				else
				{//Set to min size

					//Take record of the window's old center position so that resized window can be nicely centered at the same position
					glm::vec2 oldCenterPos(getXGlobal() + size.x / 2.0f, getYGlobal() + size.y / 2.0f);

					//Rezise to min size
					setSize(minSize);

					//Reposition relative to old center position (recorded earlier)
					setPositionLocal(oldCenterPos.x - size.x / 2.0f, oldCenterPos.y - size.y / 2.0f);

					//Position window so that it won't go out of the application window
					limitWithinMainWindow();
				}
			}
			else
				doubleClickTimer = DOUBLE_CLICK_TIME;
		}

		//Check exit button
		if (checkState(GUIRECT_ENABLED_BIT) && inputManager->isKeyPressed(MOUSE_BUTTON_LEFT) && exit->getMouseHover())
			close();

	}
예제 #14
0
int main()
{
    
  initShadowRegisters();  
    
  TRISC = 0; //RC0 as Output PIN
  //TRISC1 = 0;
  
  
  
  //Clear Analog Inputs and make pins digital pins
  ANSEL=0b00000001;//set RA0 as analog pin
  ANSELH=0;
  
  IRCF0 = 0b111;//set prescaler
  
  UART_Init();
  
  UART_writeString("Startup ... done\n");
  
  
  
  //ADC
    //Select ADC conversion clock Frc
    ADCON1bits.ADCS = 0b111;
     //Configure voltage reference using VDD
    ADCON0bits.VCFG = 0;
    //Select ADC input channel (RA0/AN0)
    ADCON0bits.CHS = 0;
    //Select result format right justified
    //right=1 is good when using all 10 bits the two bytes can be concatenated 
    //easily into an integer
    //left=0 is good when using the 8 most significant bits
    ADCON0bits.ADFM = 1;
    //Turn on ADC module
    ADCON0bits.ADON = 1;
  

        
  
  while(1)
  {
//---------------------------------------------    
    //Blink LED on RC0 and RC1
    SetBitReg(Reg_PORTC,0,HIGH);
    SetBitReg(Reg_PORTC,1,LOW);

    __delay_ms(100); // 100ms Delay

    SetBitReg(Reg_PORTC,0,LOW);
    SetBitReg(Reg_PORTC,1,HIGH);

    __delay_ms(100); // 100ms Delay
//---------------------------------------------        

    
//--------------------------------------------- 
    //UART communication
    while(UART_DataAvailable()>0){
        //char a=UART_ReadByte();
        //UART_writeByte(a);
        //UART_writeByte('\n');
        
        UART_writeNumber(UART_DataAvailable());
        UART_writeByte('\n');  
        
        UART_writeString(UART_ReadString());
        UART_writeByte('\n');
    }
    
    if(UART_DataAvailable()<0){
        UART_writeString("Data Lost Reset UART\n");
        UART_Reset();
    }
    
    //Print a Register
 // UART_writeBitPattern(ANSELH);
 // UART_writeByte('\n');
//---------------------------------------------        

    
//---------------------------------------------    
        
    //Read ADC
    Get_Inputs();
    unsigned int ADC_Value=0;
    
    ADC_Value=ADRESH<<8 | ADRESL;
 
    UART_writeNumber(ADC_Value);
    UART_writeByte('\n');
    
    if(checkBit(ShadowPortC,1)>0)
       SetBitReg(Reg_PORTC,2,HIGH); 
    

 //---------------------------------------------    
  }
  return 0;
  
 
}
예제 #15
0
파일: TSP.cpp 프로젝트: Torhemp/University
//TSP 본체
int travel(int start, const int W[][13], int P[][4096], int b[], int D[][MAX_BINT]){
	//반복 변수
	int i, j, k;
	//D가 되는 개수 변수, 주소 변수
	int cnt=0, index=0;
	//부분집합을 표현하는 비트
	int bitS=0;
	//임시 D값 저장 배열, 임시 최단 거리 주소 저장 배열
	int temp[12]={MAX,MAX,MAX,MAX,MAX,MAX,MAX,MAX,MAX,MAX,MAX,MAX},
		indexP[12]={0,};
	//출발점 제외한 나머지 거리에서 도착점까지 최단 경로 저장
	for(i=1;i<=CITYCOUNT;++i)
		if(i!=start)
			D[i][0]=W[i][start];
	//부분집합 1~10개의 경우 계산
	for(k=1;k<=CITYCOUNT-2;++k){
		//개수에 맞는 최초부분집합 계산
		bitS=0;
		for(j=0;j<=k;++j){
			b[j]=1;
			bitS |= (int)pow(2.0, j);
		}
		b[start-1]=0;
		bitS ^= (int)pow(2.0, start-1);
		while(1){
			for(j=1;j<=CITYCOUNT;++j){
				//부분집합 A, 출발점에 포함되면 넘어감
				if((bitS & (1<<(j-1)))>0)
					continue;
				//A인 경우에 D행렬, P행렬의 일부 계산
				for(i=1, cnt=0;cnt<k;++i){
					if((bitS & (1<<(i-1)))>0){
						temp[cnt]=W[j][i]+D[i][bitS^(1<<i)];
						indexP[cnt]=i;
						++cnt;
					}
				}
				D[j][bitS]=minD(temp, cnt, &index);
				P[j][bitS]=indexP[index];
			}
			//비트수 검사하여 개수 맞으면 계속 진행, 범위 초과시 종료
			while(1){
				++bitS;
				//범위 초과시 반복 종료
				if(bitS>4095)
					break;
				//개수 일치 시 반복 종료
				else if(checkBit(bitS)==k)
					break;
			}
			//범위 초과 시 구문 종료
			if(bitS>4095)
				break;
		}
	}
	//출발 제외한 나머지 경로 거칠 때 경우 계산
	bitS=4095;
	bitS^=(int)pow(2.0, start-1);
	for(i=1, cnt=0;cnt<CITYCOUNT-1;++i){
		if((bitS & (1<<(i-1)))>0){
			temp[cnt]=W[start][i]+D[i][bitS^(1<<j)];
			indexP[cnt]=i;
			++cnt;
		}
	}
	D[start][bitS]=minD(temp,cnt,&index);
	P[start][bitS]=indexP[index];
	return D[start][bitS];
}
예제 #16
0
void Game::run()
{

	//Connect TCP
	bool success = false;
	do
	{
		try
		{
			serverEndpointTCP = *resolverTCP.resolve(queryTCP);
			socketTCP.open(boost::asio::ip::tcp::v4());
			socketTCP.connect(serverEndpointTCP);

			//Send enter packet to server
			boost::array<unsigned char, 1> enterPacket = { packet::enter };
			socketTCP.send(boost::asio::buffer(enterPacket));
			socketTCP.send(boost::asio::buffer(enterPacket));
			socketTCP.send(boost::asio::buffer(enterPacket));

			//Wait for receiving return data
			size_t bytes = socketTCP.receive(boost::asio::buffer(receiveBufferTCP));
			boost::system::error_code e;
			receiveHandlerTCP(e, bytes);
			success = true;
		}
		catch (std::exception& e)
		{
			std::cout << "\n" << e.what();
		}
	} while (!success);

	//Connect UDP
	success = false;
	do
	{
		try
		{
			serverEndpointUDP = *resolverUDP.resolve(queryUDP);
			socketUDP.open(boost::asio::ip::udp::v4());
			socketUDP.connect(serverEndpointUDP);
			boost::array<unsigned char, sizeof(CLIENT_ID_TYPE) + sizeof(packet::PacketType)> enterUDP;
			enterUDP[0] = packet::enterUdpEndpoint;
			memcpy(&enterUDP[sizeof(packet::PacketType)], &ID, sizeof(ID));
			socketUDP.send(boost::asio::buffer(enterUDP));
			socketUDP.receive(boost::asio::buffer(enterUDP));//Wait for server response
			success = true;
		}
		catch (std::exception& e)
		{
			std::cout << "\n" << e.what();
		}
	} while (!success);
	

	std::thread ioServiceThread(boost::bind(&boost::asio::io_service::run, &ioService));
	while (!checkBit(state, GAME_EXIT_BIT))
	{
		mainWindow->clearBuffer();
		spehs::beginFPS();

		//Update
		spehs::console::update();
		inputManager->update();
		update();

		//Render
		render();
		spehs::console::render();

		spehs::endFPS();
		spehs::drawFPS();
		mainWindow->swapBuffers();

		if (inputManager->isKeyDown(KEYBOARD_Q))
			enableBit(state, GAME_EXIT_BIT);
	}

	//Notify server
	exitGame();
	ioServiceThread.join();
}