コード例 #1
0
void redraw(unsigned int* framePointer)
{
	drawAliens();
	drawHUD();
	drawBullets(0x00FF0000);
	draw_bunker(0x0000FF00);
	draw_tank(0x0000FF00);
	drawAliens();
	drawHUD();
	drawBullets(0x00FF0000);
	draw_bunker(0x0000FF00);
	draw_tank(0x0000FF00);
}
コード例 #2
0
void drawGame(void) {
	GLint i;

	polycount = 0;

	clearScreen();

	glShadeModel( GL_SMOOTH );
	glDepthMask(GL_TRUE);
	glEnable(GL_DEPTH_TEST);

	for(i = 0; i < vp_max[gViewportType]; i++) {
		Player *p = game->player + viewport_content[i];
		PlayerVisual *pV = gPlayerVisuals + viewport_content[i];
		Visual *d = & pV->display;

		if(d->onScreen == 1) {
			glViewport(d->vp_x, d->vp_y, d->vp_w, d->vp_h);
			drawCam(p, pV);

			/* hud stuff for every player */
			drawHUD(p, pV);
		}
	}
	/* printf("%d polys\n", polycount); */
}
コード例 #3
0
ファイル: testApp.cpp プロジェクト: readywater/ofproj
void testApp::draw(){
    ofBackgroundGradient(ofColor(65,62,50),ofColor(25,22,10) );
    ofSetColor(255);
    ofPushMatrix();
    ofTranslate(200,0);
    glEnable(GL_DEPTH_TEST); // Manually enable for controlpanel
    camera.begin();
    
    //Create mesh
    if(panel.getValueB("manualCamera")) {
        camera.setPosition(ofVec3f(panel.getValueF("lightx"),panel.getValueF("lighty"),panel.getValueF("lightz")));
    }
    
    ofRotateZ(152.0f);
    ofRotateX(panel.getValueF("rotate"));
    
    //Draw loop

    graph.bind();
        if(panel.getValueB("wireframe")) {
            mesh.drawWireframe();
        } else { 
            mesh.draw(); 
        }
    graph.unbind();
    camera.end();
    ofPopMatrix();
    glDisable(GL_DEPTH_TEST); // Manually disable, then draw text + ofxACP
    drawHUD();
}
コード例 #4
0
ファイル: ingamestate.cpp プロジェクト: x0b1t/openrw
void IngameState::draw(GameRenderer* r)
{
	if( !getWorld()->state->isCinematic && getWorld()->isCutsceneDone() )
	{
		drawHUD(_look, game->getPlayer(), getWorld(), r);
	}
	
    State::draw(r);
}
コード例 #5
0
ファイル: two.c プロジェクト: robbykraft/InfiniteZoom
void draw2D(){

	glPushMatrix();  // TRANSLATE & SCALE: (0,0) to center, screen width to 1.0
		glTranslatef(WIDTH*0.5, HEIGHT*0.75, 0.0f);
		glScalef(WIDTH, WIDTH, WIDTH);
		// NOW: dimensions are 1.0 = width of screen

		drawGround();
		glScalef(INTERVAL*INTERVAL, INTERVAL*INTERVAL, INTERVAL*INTERVAL);

		glPushMatrix();  // SCALE: zoom cycle
			glScalef(zoomCycleScale, zoomCycleScale, zoomCycleScale);

			for(int i = LVL_LOW; i < LVL_HIGH; i++){
				glPushMatrix();
				// with each zoom level we also calculate the fmodf of the translation

					float lvlWidth = 1.0/powf(INTERVAL, i);
					int lvlTransWhole = -transExp / lvlWidth;
					float lvlTransPart = modf(-(transExp)/lvlWidth, &unused);

					// int lvlTransWhole_OFF = -transExp / lvlWidth - 0.5;
					// float lvlTransPart_OFF = modf(-(transExp)/lvlWidth - 0.5, &unused);
					// glTranslatef(-transExp - lvlTransWhole_OFF * lvlWidth, 0, 0);

					int lvlTransWhole_OFF = -transExp / lvlWidth - 0.5*(INTERVAL_IS_ODD);
					float lvlTransPart_OFF = modf(-(transExp)/lvlWidth - 0.5*(INTERVAL_IS_ODD), &unused);
					glTranslatef(-transExp - (lvlTransWhole_OFF - 0.5*(!INTERVAL_IS_ODD)) * lvlWidth, 0, 0);

					float scale = powf(INTERVAL, i);
					float color = (i-zoom) / (LVL_HIGH-LVL_LOW);
					glScalef(1.0/scale, 1.0/scale, 1.0/scale);

					sprintf(zoomReports[i], "%f : (%d) %f : [(%d) %f]", lvlWidth, lvlTransWhole, lvlTransPart, lvlTransWhole_OFF, lvlTransPart_OFF);

					unsigned char highlight = 0;
					for(int i = 1; i <= INTERVAL; i++){
						float seg = (float)i / INTERVAL;
						if(fabs(lvlTransPart_OFF) < seg){
							highlight = i;
							break;
						}
					}

					repeating2DScene(color, highlight);
				glPopMatrix();
			}
		glPopMatrix();  // SCALE: zoom cycle
	glPopMatrix();  // TRANSLATE & SCALE: (0,0) to center, screen width to 1.0

	if(showHUD)
		drawHUD();
}
コード例 #6
0
ファイル: visuals.c プロジェクト: ChrisCooper/SPQR
/*  gameVisuals()

Draws the map, people, HUD, and mouse, in that order.

*/
void gameVisuals()
{      
   drawGrid ();                                          //Draws map and people
	if (mouseGridX >= 0 && mouseGridY >= 0)
	{
		//Draw the map highlighter
 		draw_sprite(screenBuffer, selector, placeOnGridX(mouseGridX, mouseGridY),placeOnGridY(mouseGridX, mouseGridY));
	}
   drawHUD();
	draw_sprite(screenBuffer, mousePic, mouseX, mouseY);

	blit(screenBuffer, screen, 0,0,0,0,1024,768);         //Blit the buffer
   clear_bitmap(screenBuffer);
}
コード例 #7
0
ファイル: Player.cpp プロジェクト: rycirese/CS495
void Player::draw() {
    glColor4f( 1.0f, 1.0f, 1.0f, 0.0f);
    GLfloat xtrans = -xpos; //Used For Player Translation On The X Axis
    GLfloat ztrans = -zpos; //Used For Player Translation On The Z Axis
    GLfloat ytrans = -walkbias-0.25f; //Used For Bouncing Motion Up And Down
    GLfloat sceneroty = 360.0f-yrot; //360 Degree Angle For Player Direction

    glRotatef(0.0f, 1.0f, 0.0f , 0.0f); //Rotate Up And Down To Look Up And Down
    glRotatef(sceneroty, 0.0f, 1.0f , 0.0f); //Rotate Depending On Direction Player Is Facing
    glTranslatef(xtrans, ytrans, ztrans); //Translate The Scene Based On Player Position

    drawHUD();
    check();
}
コード例 #8
0
ファイル: main.cpp プロジェクト: ohmyitscasper/Theme7
void display()
{
  glClear(GL_COLOR_BUFFER_BIT);

	glMatrixMode(GL_MODELVIEW);

  assert( g_executable_simulation != NULL );
  g_executable_simulation->renderSceneOpenGL();

  drawHUD();

  glutSwapBuffers();

  assert( renderingutils::checkGLErrors() );
}
コード例 #9
0
ファイル: Renderer.cpp プロジェクト: freshone/game-demo
void Renderer::display(void)
{
	//clear window
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glLoadIdentity();

	//draw splash screen
	if(splash){
		glEnable(GL_TEXTURE_2D);
		glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
		glBindTexture(GL_TEXTURE_2D, textureID[3]);
		glPushMatrix();

		glBegin(GL_QUADS);
			glTexCoord2f(0.0f, 1.0f); glVertex3f(-1, 1, -2);
			glTexCoord2f(0.0f, 0.0f); glVertex3f(-1, -1, -2);
			glTexCoord2f(1.0f, 0.0f); glVertex3f(1, -1, -2);
			glTexCoord2f(1.0f, 1.0f); glVertex3f(1, 1, -2);	
		glEnd();
		
		glPopMatrix();
		glDisable(GL_TEXTURE_2D);
	}
	else {
		if(lighting){
			glEnable(GL_LIGHTING);
		}
		
		glPushMatrix();									//Push -- camera
		glLoadMatrixd(camera->getModelViewMatrix());
		
		glPushMatrix();									//Push -- draw world
		drawRoom();
		glPopMatrix();									//Pop  -- draw world

		drawTreasures();
		glPopMatrix();									//Pop  -- camera

		if(lighting){
			glDisable(GL_LIGHTING);
		}

		drawHUD();
		frameCount++;
	}
	glutSwapBuffers();
}
コード例 #10
0
// functia de display
void display(void)
{

    // de fiecare data cand desenam, la inceput resetam toate bufferurile a.i
    // ele sa aiba valorile initiale definite de functiile:
    // glClearColor ... va seta culoarea backgroundului, vezi init
    // glClearDepth ... va seta valoarea cea mai indepartata a adancimii (adica 1), pentru
    // ca suntem in coordonate fereastra
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    //Deseneaza scena
    drawScene();
    drawHUD();

    //Schimba bufferele
    glutSwapBuffers();
}
コード例 #11
0
ファイル: manager.cpp プロジェクト: SupriyaNarayan/C-C-
void Manager::draw() const {
  kungfuback.draw();
  for (unsigned i = 1; i < sprites.size(); ++i){
    sprites[i]->draw();
  }
  kungfu.draw();
  std::list<ExplodingSprite*>::const_iterator itr = explodingSprite.begin();
  while(itr != explodingSprite.end() ){
    (*itr)->draw();
    ++itr;
  }
  if(healthLeft) sprites[0]->draw();
  io.printMessageAt(title, 10, 460);
  if(!healthLeft) {
    clock.pause();
    io.printMessageValueAt("Your final score is ", score, 290, 200);
  }
  viewport.draw();
  io.printMessageValueAt("Your score is ", score , 10 , 440);
  drawHUD();
  SDL_Flip(screen);
}
コード例 #12
0
void drawGame(void) {
	GLint i;

	clearScreen();

	glShadeModel( GL_SMOOTH );
	glDepthMask(GL_TRUE);
	glEnable(GL_DEPTH_TEST);

	for(i = 0; i < vp_max[gViewportType]; i++) {
		Visual *d = &gPlayerVisuals[viewport_content[i]].display;

		if(d->onScreen == 1) {
			glViewport(d->vp_x, d->vp_y, d->vp_w, d->vp_h);
			drawCam(viewport_content[i]);

			/* hud stuff for every player */
			drawHUD(game->player + viewport_content[i],
				gPlayerVisuals + viewport_content[i]);
		}
	}
}
コード例 #13
0
ファイル: Writer.cpp プロジェクト: MrMoDDoM/MuHi
int main(){

	bool fin = false;

	int STEP_WAIT = 100;

	Mat HUD = Mat::zeros(Y_RESOLUTION, X_RESOLUTION,  CV_8UC3);

	int step = 0;
	if(initWriter())
		return -1;

	while(!fin){
		step ++;

		int c = waitKey(10);
		if( (char)c == 27 ) { fin = true; } //Esc key
		if( (char)c == '+') { STEP_WAIT = STEP_WAIT + 2; }
		if( (char)c == '-') { STEP_WAIT = STEP_WAIT - 2; }
		if( (char)c == '0') { checkBlink(0); }
		if( (char)c == '1') { checkBlink(1); }
		if( (char)c == '2') { checkBlink(2); }
		if( (char)c == '3') { checkBlink(3); }
		if( (char)c == '4') { checkBlink(4); }

		drawHUD(&HUD);

		std::cout<<"Tasto: "<<c<<std::endl;

		if(step >= STEP_WAIT){
			step = 0;
			stepWriter();
		}

		imshow("Writer",HUD);
	}
	return 0;
}
コード例 #14
0
ファイル: main.cpp プロジェクト: mentatzoe/CMPS164
void draw(Level lvl)
{
	//Clear color buffer
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	//handleCamera();

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(FoV, WINDOW_WIDTH / WINDOW_HEIGHT, 0.1, 100);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	// Render Camera
	camera.render();

	glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);
	glLightfv(GL_LIGHT0, GL_AMBIENT, ambientColour);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseColour);
	glLightfv(GL_LIGHT0, GL_SPECULAR, specularColour);

	glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
	glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
	glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_emission);

	glPushMatrix();

	// Draw Level
	lvl.draw();

	glPopMatrix();
    
	// Draw HUD
    drawHUD(lvl);

	SDL_GL_SwapWindow(gWindow);
}
コード例 #15
0
ファイル: HUD.cpp プロジェクト: GuyMac111/BlockMassacre
void HUD::drawGameOver(int score, int multiplier, int timeRemaining, int sizeX, int sizeY)
{
	drawHUD(score, multiplier, timeRemaining);
	//Draw a transparent grey quad over the screen to dim for pausing
	//Set colour
	glColor4f(0.4f,0.4f,0.4f,0.9f);
	glBegin(GL_QUADS);
	glVertex2f(0,0);
	glVertex2f(0,sizeY);
	glVertex2f(sizeX, sizeY);
	glVertex2f(sizeX, 0);
	glEnd();
	//set the colour back to normal
	glColor4fv(scoreTextColour);
	//write "TIME OVER"
	printWithColour(pauseFont, (sizeX/2)-(pauseFont.h*3),sizeY/2+(sizeY/3),scoreTextColour,"TIME OVER");
	if(GO_scoreTimer > 0)GO_scoreTimer--;//count down until we should show the score
	
	if(GO_scoreTimer == 0) //once our artificial interval is over
	{	
		//If the scoretimer has hit zero we can display the score 
		//ticking up to the score the player has reached
		char scoreAstext[10];
		sprintf(scoreAstext,"%.0f",GO_score);
		//We want to align the score RIGHT, as is the tradition with scores. So that the text moves
		//LEFT as the number of digits increases.

		float offset = getStringWidth(GO_scoreFont,0,0,scoreAstext);
		
		//UPDATE: SKIPPING FUNCTIONALITY BE HERE
		//by way of a skipping flag that is waved by the mainclass via a public
		if(skipGO_flag)//false by default
		{
			GO_score = score;//auto-meet the conditions to end the "ticking-up" loop
		}


		if(GO_score<score)
		{//If GO_score is less than score, 
			//print the score white as it is clocking up
			printWithColour(scoreTextFont,(sizeX/2)-100, (sizeY/2)+(sizeY/3)-((GO_scoreFont.h*2)-5),GO_scoreColour, "SCORE:");
			printWithColour(GO_scoreFont, (sizeX/2)+(sizeX/3)-offset,(sizeY/2)+(sizeY/3)-((GO_scoreFont.h*2)-5),GO_scoreColour,scoreAstext);
			float scorePerFrame = score/120;//continue adding to GO_score
			GO_score += scorePerFrame;//divided by the number of frames we want it to take
		}else{
			//if the GO_score has reached its destination, still draw it,
			//but start pulsating
			
			//ALSO throughout the 'clocking up', GO_Score can become 
			//distorted slightly through rounding up and whatnot. 
			//So once we're up here, let's just draw the ACTUAL score.

			char actualScoreAsText[10];
			_itoa(score, actualScoreAsText, 10);
			printWithColour(scoreTextFont,(sizeX/2)-100, (sizeY/2)+(sizeY/3)-((GO_scoreFont.h*2)-5),GO_scoreColour, "SCORE:");
			printWithColour(GO_scoreFont, (sizeX/2)+(sizeX/3)-offset,(sizeY/2)+(sizeY/3)-((GO_scoreFont.h*2)-5),GO_scoreColour,actualScoreAsText);
			pulsateColour(white,blue, GO_scoreColour, CS_GO_score, 20);

			//retry
			float retryOffset = getStringWidth(GO_retryFont,0,0,"Press 'r' to retry")/2;
			float quitOffset = getStringWidth(GO_retryFont,0,0,"Press 'q' to return to the menu")/2;
			printWithColour(GO_retryFont, (sizeX/2) - retryOffset,100, white,"Press 'r' to retry");
			printWithColour(GO_retryFont, (sizeX/2) - quitOffset,100-(GO_retryFont.h+3), white,"Press 'q' to return to the menu");
			
		}

	}

	
}
コード例 #16
0
ファイル: anaglyph.cpp プロジェクト: Caellian/minetest
void RenderingCoreAnaglyph::drawAll()
{
	renderBothImages();
	drawPostFx();
	drawHUD();
}
コード例 #17
0
ファイル: interlaced.cpp プロジェクト: ShadowNinja/minetest
void RenderingCoreInterlaced::drawAll()
{
	renderBothImages();
	merge();
	drawHUD();
}
コード例 #18
0
ファイル: PlaySpace.cpp プロジェクト: API-Beast/ShinyAvenger
void PlaySpace::draw()
{	
	RenderTarget* oldTarget = Renderer.Context.renderTarget();
	
	if(oldTarget->size() != HDRTarget->size())
	{
		delete HDRTarget;
		HDRTarget = new Framebuffer(oldTarget->size().X, oldTarget->size().Y, 16);
	}
	Renderer.Context.setRenderTarget(HDRTarget);
	float alphaMult = Max(Renderer.Context.Camera.Zoom.length()+0.2f, 0.0f);
	alphaMult *= alphaMult;
	alphaMult = Min(alphaMult-0.1f, 1.0f);
	Renderer.clear(Colors::Dawnbringer::Clay[0] / 1.5f * (1-alphaMult));
	
	auto& r = Renderer;
	
	if(alphaMult > 0.05f)
	{
		r.drawRepeatedInf(gAssets.BG.Stars, 0, 1.00f, 0.05f, Vec4F(Colors::White, 0.75f * alphaMult));
		r.drawRepeatedInf(gAssets.BG.Fog2,  0, 4.20f, 0.15f, Vec4F(0.22f, 0.15f, 0.14f, 0.5f * alphaMult));
		r.drawRepeatedInf(gAssets.BG.Stars, 0, 1.20f, 0.25f, Vec4F(Colors::White, 0.75f * alphaMult));
		r.drawRepeatedInf(gAssets.BG.Fog1,  0, 3.90f, 0.40f, Vec4F(0.22f, 0.15f, 0.14f, alphaMult));
		r.drawRepeatedInf(gAssets.BG.Stars, 0, 1.60f, 0.58f, Vec4F(Colors::White, alphaMult));
		r.drawRepeatedInf(gAssets.BG.Fog2,  0, 2.75f, 0.80f, Vec4F(0.32f, 0.20f, 0.14f, alphaMult));
	}
	
	
	for(GravitySource& src : GravitySources)
		src.draw(r);
	
	for(Bullet& obj : Bullets)
		obj.draw(r);
	for(PhysicsObject* obj : Objects)
		obj->draw(r);
	for(Particle& particle : Particles)
		particle.draw(r);
	
	for(GravitySource& src : GravitySources)
		src.drawTop(r);
	for(Bullet& obj : Bullets)
		obj.drawTop(r);
	
	r.flush();
	Renderer.Context.setRenderTarget(oldTarget);
	Renderer.clear(Colors::Black);
	Renderer.Context.setShader(gAssets.ToneMapping);
	Renderer.drawRenderpass(*HDRTarget);
	Renderer.Context.setShader(ShaderProgram::GetDefaultShader());
	
	if(Player)
		drawHUD();
	
	float sizeMult = 1.f + (1.f / Renderer.Context.Camera.Zoom.length());
	if(sizeMult > 3)
	{
		for(PhysicsObject* obj : Objects)
			obj->drawPictogram(r, sizeMult);
	}
	
	r.flush();
}
コード例 #19
0
ファイル: main.cpp プロジェクト: samcorcoran/jewelMatcher
int main( int argc, char* args[] )
{
	bool quit = false;

	if ( init() == false ){
		return 1;
	}

	if ( load_files() == false )
	{
		return 1;
	}

	messageString = "Jewel Matcher";
	message = TTF_RenderText_Solid( font, messageString.c_str(), textColor );
	if ( message == NULL )
	{
		return 1;
	}

	//Apply image to screen
	apply_surface( 0, 0, backgroundImage, screen );

	// Construct Grid of Sockets and Jewels
	// Based on arbitary grid width provided, determine grid starting coordinates
	Grid* gameGrid = new Grid(GRID_SIZE, GRID_CENTRE_X, GRID_CENTRE_Y, CELL_W, CELL_H);

	// Pausing prevents game behaviours, stops timer, stops interaction other than unpausing, but continues draw calls
	bool isPaused = false;
	// Flag indicating whether game has finished
	bool gameOver = false;
	// Game score counts points player has earned during current game
	int gameScore = 0;

	// If the game is animating someting, interaction is prevented
	bool gridReady = true;
	// To prevent continuous searching for color groups when the grid has not changed, false flag indicates no need to search
	bool gridChanged = false;

	// Track whether (and where) an upClick has occurred
	bool upClickOccurred = false;
	int mUpClickX = 0;
	int mUpClickY = 0;

	// Track whether the player has moved a jewel
	bool moveMade = false;
	// If an illegal move is made (no color groups formed), flag indicates they must be switched back
	bool legalMove = true;

	// Game start time
	int gameStartTime = SDL_GetTicks();
	int totalTimeElapsed = 0;
	int currentTime = gameStartTime;
	// Track time from previous iteration, for calculating delta-time
	int prevTime = gameStartTime;
	// Change in time since last tick
	int deltaTime = 0;
	// Increase counter 'accumulatedTime' until it reaches threshold of fixedTimeStep, prompting movements/animations to be performed
	int accumulatedTime = 0;
	// Used to instill regularity in animation
	int fixedTimeStep = 1000;
	// Controls whether functions are fed 0 or fixedTimeStep as their deltaTime
	int animationTime = 0;

	// Illegal moves incur a momentary pause before jewels are switched back
	// A counter will accumulate animationTime until 
	int switchBackTimeTarget = 11000;
	int switchBackTimeCounter = 0;

	//Pause
	while( quit == false )
	{
		// Event handling
		while( SDL_PollEvent( &event ) )
		{
			// When exiting the program
			if( event.type == SDL_QUIT )
			{
				//Exit
				quit = true;
			}

			// Track mouse coordinates
			if( event.type == SDL_MOUSEMOTION )
			{
				mouseX = event.motion.x;
				mouseY = event.motion.y;
			}

			// On key-up of 'p' key, pause the game
			if ( event.type == SDL_KEYUP )
			{
				if( event.key.keysym.sym == SDLK_p )
				{
					// Toggling pause
					isPaused = !isPaused;
				}
			}

			// User Game interaction - EVENTS WHICH OCCUR WHEN BOARD IS STATIC
			if ( event.type == SDL_MOUSEBUTTONUP )
			{
				// Click-down's don't matter as much as click-ups
				if( event.button.button == SDL_BUTTON_LEFT )
				{
					upClickOccurred = true;
					mUpClickX = event.button.x;
					mUpClickY = event.button.y;
				}
			}
		
		} // End of poll event clearing

		// Update timer information
		if( !gameOver && !isPaused )
		{
			// Determine how much time has elapsed since last iteration
			currentTime = SDL_GetTicks();
			// Time elapsed is 
			totalTimeElapsed = currentTime - gameStartTime;
			deltaTime =  currentTime - prevTime;
			accumulatedTime += deltaTime;
			animationTime = 0;
			if( accumulatedTime >= fixedTimeStep )
			{
				animationTime = fixedTimeStep;
				// Accumulation variable can keep remainder after fixedTimeStep is taken away from it, as long as remainder is less than fixedTimeStep
				accumulatedTime = accumulatedTime % fixedTimeStep;
			}
		}

		// Pause inhibits user input and animation
		if( isPaused && !gameOver )
		{
			// Set message so user understands what state game is in and why interaction is halted.
			messageString = "Paused - 'p' to Continue";

			// Up-Clicks occuring during paused game state are rejected
			upClickOccurred = false;
		}
		else
		{		
			messageString = "Jewel Matcher";

			// Reset flag before checking conditions
			gridReady = false;
			// Check if sockets are full
			gridReady = gameGrid->socketsAreFull( animationTime );
			// Check if jewels are moving
			gridReady = gameGrid->jewelsAreStatic( animationTime );

				
			if( !gridReady )
			{	
				// Grid has undergone change from sockets being filled or jewels moving
				gridChanged = true;
			}
			else
			{
				// To protect against repeated searched of an un-changed grid, check if the last search set 
				if( gridChanged )
				{
					// Reset the flag to show that 
					gridChanged = false;
					if( searchForScoringGroups( gameGrid, gameScore ) )
					{
						// Groups were found and scored. Sockets will no longer be full.
						gridReady = false;
						if( moveMade )
						{	
							// Reset the flag
							moveMade = false;
							// Player switched jewels, but no resulting groups have been found
							legalMove = true;
						}
					}
					else
					{
						if( moveMade )
						{	
							// Reset the flag
							moveMade = false;
							// Player switched jewels, but no resulting groups have been found
							legalMove = false;
						}
					}
				}
			}


			// Check if the game timer has run out yet
			if( totalTimeElapsed < totalGameLength )
			{
				// Only allow user mouse interaction if game is not handling grid animation etc
				if( !gridReady )
				{
					// If grid is not ready...
					// - prompt empty sockets to steal/generate jewels
					// - prompt jewels to move towards their destinations
				}
				else
				{
					// Animations have been resolved, grid is ready for input

					// Illegal moves require jewels to be switched back before the game can continue
					if( !legalMove )
					{
						switchBackTimeCounter += animationTime;
						if( switchBackTimeCounter >= switchBackTimeTarget )
						{	
							// Reset switchback delay variable
							switchBackTimeCounter = 0;

							// Jewel exchange reversal can only occur if two sockets are selected
							if( selectedSockets.size() == 2 )
							{
								// Invalid move by those currently in selection must be reversed
								gameGrid->attemptJewelExchange( selectedSockets.at(0), selectedSockets.at(1) );
							}

							// Indicate switchback has been completed
							legalMove = true;
							// Deselect sockets involved in switch back
							selectedSockets.clear();
						}
					}
					else
					{
						// If an upClick occurred, check if it was within grid
						if( upClickOccurred )
						{ 
							if( gameGrid->withinBound( mUpClickX, mUpClickY ) ) 
							{
								// Reset the flag for the next upclick
								upClickOccurred = false;
								// Execute behaviour for selecting sockets at coordinates
								moveMade = performSocketSelection( mUpClickX, mUpClickY, gameGrid );							
							}
							else
							{							
								// Clicking outside of the grid is used for deselection
								selectedSockets.clear();
							}
						}
					}
				} // End of gridReady/!gridReady statement
			} 
			else
			{	
				// Full game length has elapsed 
				gameOver = true;
			}
		} // End of pause/!pause statement
		

		// Draw background and game visuals
		apply_surface( 0, 0, backgroundImage, screen );
		drawGrid( gameGrid );

		drawHUD( totalTimeElapsed, gameScore );

		if( gameOver )
		{
			// Draw score
			messageString = "Game Over";
		}

		// Refresh message	
		renderCentredText( 410, 55, messageString );

		//Update screen
		if ( SDL_Flip( screen ) == -1 )
		{
			return 1;
		}
	}

	// Free-up surfaces, destroy objects and quit SDL
	clean_up( gameGrid );
    
    return 0;    
}