Sorry your browser is not supported!

1. Anybody may enter any challenge, as many times as they like, so long as all code is written in DGDK. 

2. No external media is allowed

3. The person who wins the current challenge becomes the next challenge setter.

4. The challenge setter is the judge for the current challenge, and must select a winner and a runner up.

5. The challenge setter may enter, but may not judge him/herself the winner.

6. The challenge setter will set the time limit according to difficulty. The challenge setter may extend the deadline by 24 hours if there is a very good reason, but extensions must not be made during the final 24 hours of the challenge.

7. If nobody enters within the time limit, the challenge setter must set a new challenge.

8. If the challenge setter fails to judge entries or set a new challenge within 24 hours of the deadline, responsibility for judging and setting a new challenge will pass to the previous runner up. If that person also fails to act promptly, entrants may vote for a winner and new challenge.

9. You may use code from any other entries within the challenges thread for your current entry, so long as you improve upon it in some way and give credit.

// Import Dark GDK
#include "DarkGDK.h"



// Function declarations
int		NewObject( void );
int		CreateBat( DWORD Color );
void	CreateWall( float x1, float z1, float x2, float z2, DWORD Color );
void	HandleBat( int Bat, float ArenaWidth, float Speed );


// Main entry point
void DarkGDK( void )
{


	// Setup
	dbSyncOn();
	dbSyncRate( 60 );
	dbRandomize( dbTimer() );

	// Settings
	dbSetDisplayMode( 1440, 900, 32 );					// CHANGE THIS LINE TO FIT YOUR DISPLAY MODE
	dbMaximizeWindow();
	dbHideMouse();
	dbBackdropOn();
	dbColorBackdrop( 0x00000000 );
	dbAutoCamOff();
	dbSetCameraRange( 1.0f, (float)0x7fffffff );
	dbSetAmbientLight( 100 );

	// Create player and enemy bats
	int Player	= CreateBat( dbRGB( 0, 0, 255 ) );
	int Enemy	= CreateBat( dbRGB( 255, 0, 0 ) );
	float EnemyDifficulty	= 20.0f;					// Enemy Difficulty: The higher, the easier

	// Position bats
	dbPositionObject( Player, 0.0f, 15.0f, -500.0f );
	dbPositionObject( Enemy, 0.0f, 15.0f, 500.0f );

	// Position Camera
	dbPositionCamera( 0.0f, 300.0f, -800.0f );
	dbPointCamera( 0.0f, 0.0f, 0.0f );


	// Create arena
	float ArenaWidth	= 600.0f;
	float ArenaLength	= 1100.0f;
	int Floor	= NewObject();
	dbMakeObjectPlain( Floor, ArenaWidth, ArenaLength );
	dbXRotateObject( Floor, 90.0f ); dbFixObjectPivot( Floor );
	dbColorObject( Floor, dbRGB( 0, 128, 0 ) ); dbSetObjectEmissive( Floor, dbRGB( 0, 128, 0 ) );
	dbSetObjectTransparency( Floor, 3 );
	dbSetAlphaMappingOn( Floor, 70.0f );
	dbDisableObjectZWrite( Floor );
	CreateWall( - ArenaWidth / 2, - ArenaLength / 2, - ArenaWidth / 2, ArenaLength / 2, dbRGB( 0, 255, 0 ) );
	CreateWall( ArenaWidth / 2, - ArenaLength / 2, ArenaWidth / 2, ArenaLength / 2, dbRGB( 0, 255, 0 ) );
	CreateWall( - ArenaWidth / 2, ArenaLength / 2, ArenaWidth / 2, ArenaLength / 2, dbRGB( 0, 255, 0 ) );
	CreateWall( - ArenaWidth / 2, - ArenaLength / 2, ArenaWidth / 2, - ArenaLength / 2, dbRGB( 0, 255, 0 ) );

	// Arena decorations
	int BackdpA	= NewObject();
	dbMakeObjectSphere( BackdpA, 5000.0f );
	dbRotateObject( BackdpA, (float)dbRnd( 360 ), (float)dbRnd( 360 ), (float)dbRnd( 360 ) );
	dbGhostObjectOn( BackdpA );
	dbColorObject( BackdpA, dbRGB( 0, 0, 255 ) );
	dbSetObjectAmbience( BackdpA, dbRGB( 0, 0, 255 ) );
	dbSetObjectEmissive( BackdpA, dbRGB( 0, 0, 255 ) );
	dbSetObject( BackdpA, true, false, false );
	dbSetObjectTransparency( BackdpA, 3 );
	dbSetAlphaMappingOn( BackdpA, 70.0f );
	int BackdpB	= NewObject();
	dbMakeObjectSphere( BackdpB, 5000.0f );
	dbRotateObject( BackdpB, (float)dbRnd( 360 ), (float)dbRnd( 360 ), (float)dbRnd( 360 ) );
	dbColorObject( BackdpB, dbRGB( 255, 255, 0 ) );
	dbSetObjectAmbience( BackdpB, dbRGB( 255, 255, 0 ) );
	dbSetObject(BackdpB, true, false, false );
	dbSetObjectTransparency( BackdpB, 3 );
	dbSetAlphaMappingOn( BackdpB, 70.0f );
	
	// Ball
	int Ball	= NewObject();
	dbMakeObjectSphere( Ball, 20.0f );
	dbPositionObject( Ball, 0.0f, 10.0f, 0.0f );
	dbSetObjectLight( Ball, false );
	dbSetObjectAmbient( Ball, false );

	// Ball settings
	float BallSpeed	= 20.0f;
	float BallAngle	= 300.0f + dbRnd( 120 ) + ( dbRnd( 1 ) * 180.0f );

	// Player and enemy score
	int MaxScore	= 10;		// Maximum score
	int PlayerScore	= 0;
	int EnemyScore	= 0;
	

	// Main Loop
	while( LoopGDK() )
	{

		// Handle player bat
		HandleBat( Player, ArenaWidth, (float)dbMouseMoveX() );

		// Ball Collision
		if ( dbObjectPositionX( Ball ) >= ( ArenaWidth / 2 - 20.0f ) )
		{

			// Reposition
			dbPositionObject( Ball, ( ArenaWidth / 2 - ( 20.0f + BallSpeed ) ), dbObjectPositionY( Ball ), dbObjectPositionZ( Ball ) );

			// Change ball angle
			BallAngle	= 360.0f - BallAngle;

		}
		if ( dbObjectPositionX( Ball ) <= ( - ArenaWidth / 2 + 20.0f ) )
		{

			// Reposition
			dbPositionObject( Ball, ( - ArenaWidth / 2 + ( 20.0f + BallSpeed ) ), dbObjectPositionY( Ball ), dbObjectPositionZ( Ball ) );

			// Change ball angle
			BallAngle	= 360.0f - BallAngle;

		}

		// Ball collision with player bat
		if ( ( dbObjectPositionX( Ball ) >= ( dbObjectPositionX( Player ) - 110.0f ) ) && ( dbObjectPositionX( Ball ) <= ( dbObjectPositionX( Player ) + 110.0f ) ) )
		{
			if ( ( dbObjectPositionZ( Ball ) >= ( dbObjectPositionZ( Player ) - 25.0f  ) ) && ( dbObjectPositionZ( Ball ) <= ( dbObjectPositionZ( Player ) + 25.0f  ) ) )
			{

				// Reposition ball
				dbPositionObject( Ball, dbObjectPositionX( Ball ), dbObjectPositionY( Ball ), dbObjectPositionZ( Player ) + ( 25.0f + BallSpeed ) );

				// Change angle
				BallAngle	= 180.0f - BallAngle;

			}
		}

		// Ball collision with enemy bat
		if ( ( dbObjectPositionX( Ball ) >= ( dbObjectPositionX( Enemy ) - 110.0f ) ) && ( dbObjectPositionX( Ball ) <= ( dbObjectPositionX( Enemy ) + 110.0f ) ) )
		{
			if ( ( dbObjectPositionZ( Ball ) >= ( dbObjectPositionZ( Enemy ) - 25.0f  ) ) && ( dbObjectPositionZ( Ball ) <= ( dbObjectPositionZ( Enemy ) + 25.0f  ) ) )
			{

				// Reposition ball
				dbPositionObject( Ball, dbObjectPositionX( Ball ), dbObjectPositionY( Ball ), dbObjectPositionZ( Enemy ) - ( 25.0f + BallSpeed ) );

				// Change angle
				BallAngle	= 180.0f - BallAngle;

			}
		}

		// Move ball
		dbMoveObject( Ball, BallSpeed );
		dbYRotateObject( Ball, BallAngle );
		BallAngle += 0.2f;	// Inc angle to make things interesting

		// Handle enemy AI
		if ( dbObjectPositionZ( Ball ) > 0.0f )
		{

			// If Ball X <> Enemy X, move
			if  (( dbObjectPositionX( Ball ) < ( dbObjectPositionX( Enemy ) - 0.0f ) ) || ( dbObjectPositionX( Ball ) > ( dbObjectPositionX( Enemy ) + 0.0f ) ) )
				HandleBat( Enemy, ArenaWidth, ( dbObjectPositionX( Ball ) - dbObjectPositionX( Enemy ) ) / EnemyDifficulty );

		}

		// Score player
		if ( dbObjectPositionZ( Ball ) > ArenaLength / 2.0f )
		{

			// Reposition
			BallAngle = 300.0f + dbRnd( 120 ) + ( dbRnd( 1 ) * 180.0f );
			dbPositionObject( Ball, 0.0f, dbObjectPositionY( Ball ), 0.0f );

			// Inc score
			PlayerScore++;

			// Inc Speed
			BallSpeed *= 1.02f;

			// Make enemy harder
			EnemyDifficulty = EnemyDifficulty * 0.98f;

		}

		// Score enemy
		if ( dbObjectPositionZ( Ball ) <  - ArenaLength / 2.0f )
		{

			// Reposition
			BallAngle = 300.0f + dbRnd( 120 ) + ( dbRnd( 1 ) * 180.0f );
			dbPositionObject( Ball, 0.0f, dbObjectPositionY( Ball ), 0.0f );

			// Inc score
			EnemyScore++;

			// Inc Speed
			BallSpeed *= 1.02f;

			// Make enemy harder
			EnemyDifficulty = EnemyDifficulty * 0.98f;

		}

		// If player or enemy  win
		if ( ( PlayerScore >= MaxScore ) || ( EnemyScore >= MaxScore ) )
		{

			// Infinite loop
			while( true )
			{

				// Player won or lost
				if ( PlayerScore >= MaxScore ) dbCenterText( dbScreenWidth() / 2, dbScreenHeight() / 2, "You Win!" );
				if ( EnemyScore >= MaxScore ) dbCenterText( dbScreenWidth() / 2, dbScreenHeight() / 2, "You Lost!" );
				dbCenterText( dbScreenWidth() / 2, dbScreenHeight() / 2 + 20, "Press any key to start again" );

				// If key pressed
				if ( dbScanCode() > 0 )
				{

					// Reposition ball, reposition players and reset scores
					BallSpeed = 20.0f;
					BallAngle = 300.0f + dbRnd( 120 ) + ( dbRnd( 1 ) * 180.0f );
					dbPositionObject( Ball, 0.0f, dbObjectPositionY( Ball ), 0.0f );
					dbPositionObject( Player, 0.0f, dbObjectPositionY( Player ), dbObjectPositionZ( Player ) );
					dbPositionObject( Enemy, 0.0f, dbObjectPositionY( Enemy ), dbObjectPositionZ( Enemy ) );
					PlayerScore = 0;
					EnemyScore	= 0;
					EnemyDifficulty	= 20.0f;

					// Exit
					break;

				}

				// Refresh with colored screen
				dbSync();
				if ( PlayerScore >= MaxScore )  dbCLS( dbRGB( 0, 128, 250 ) );
				if ( EnemyScore >= MaxScore )  dbCLS( dbRGB( 255, 0, 0 ) );

			}

		}

		// Show scores
		dbText( 10, 10, "Player Score:" ); dbText( 10 + dbTextWidth( "Player Score:" ), 30, dbStr( PlayerScore ) );
		dbText( dbScreenWidth() - 10 - dbTextWidth( "Enemy Score:" ), 10, "Enemy Score:" ); dbText( dbScreenWidth() - 10, 30, dbStr( EnemyScore ) );

		// Handle arena decorations
		dbTurnObjectLeft( BackdpA, (float)dbRnd(10) / 10.0f );
		dbPitchObjectUp( BackdpA, (float)dbRnd(10) / 10.0f );
		dbTurnObjectLeft( BackdpB, (float)dbRnd(10) / 10.0f );
		dbPitchObjectDown( BackdpB, (float)dbRnd(10) / 10.0f );

		// Refresh
		dbSync();

	}

	// Return to windows
	return;

}





// Get new object
int NewObject( void )
{

	// Object counter
	int Obj		= 0;
	bool Found	= false;

	// Loop til no object is found
	while( !Found )
	{
		Obj++;
		if ( dbObjectExist( Obj ) == 0 ) Found = true;
	}

	// Return object number
	return Obj;

}

// Create a bat and return object number
int CreateBat( DWORD Color )
{

	// Create object
	int Obj = NewObject();
	dbMakeObjectSphere( Obj, 100.0f, 32, 32 );
	dbScaleObject( Obj, 200.0f, 30.0f, 30.0f );
	dbColorObject( Obj, Color );
	dbSetObjectAmbience( Obj, Color );

	// Return object number
	return Obj;

}


// Create a wall
void CreateWall( float x1, float z1, float x2, float z2, DWORD Color )
{

	// Get new object
	int Obj	= NewObject();

	// Create wall
	dbMakeObjectCube( Obj, 100.0f );
	dbColorObject( Obj, Color );
	dbSetObjectAmbience( Obj, Color );

	// Get length and angle of wall, and modify object
	float Length	= dbSqrt( ( ( x2 - x1 ) * ( x2 - x1 ) ) + ( ( z2 - z1 ) * ( z2 - z1 ) ) ) + 20.0f;		// Add 20 to compensate for thickness
	float Angle		= dbAtanFull( x2 - x1, z2 - z1 );
	dbScaleObject( Obj, 20.0f, 20.0f, Length );
	dbYRotateObject( Obj, Angle );

	// Get position of wall
	float PosX	= ( x1 + x2 ) / 2.0f;
	float PosZ	= ( z1 + z2 ) / 2.0f;
	dbPositionObject( Obj, PosX, 0.0f, PosZ );

}

// Handle bat
void HandleBat( int Bat, float ArenaWidth, float Speed )
{

	// Move bat
	dbMoveObjectRight( Bat, Speed );

	// Collision
	if ( dbObjectPositionX( Bat ) <= ( - ArenaWidth / 2 + 90.0f  ) )
		dbPositionObject( Bat, ( - ArenaWidth / 2 + 100.0f  ), dbObjectPositionY( Bat ), dbObjectPositionZ( Bat ) );
	if ( dbObjectPositionX( Bat ) >= ( ArenaWidth / 2 - 90.0f  ) )
		dbPositionObject( Bat, ( ArenaWidth / 2 - 100.0f  ), dbObjectPositionY( Bat ), dbObjectPositionZ( Bat ) );

}

#ifndef _LEVELS_H
#define _LEVELS_H

/******************************************************************************
* At first glance, this might seem like it's declared backwards.  It isn't.
* When I first declared it, I had declared it as level1[40][24] but the
* subaggregate grouping in C++ specifies that the sub-groups correspond with
* the first index, not the second.
*
* As a result, throughout my program I'll be referencing these arrays [y][x]
* instead of [x][y].  I had to look this up to make sure I wasn't missing
* something.  I strongly recommend a good C/C++ reference.
******************************************************************************/
int level1[24][40] = {
	{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
	{1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1},
	{1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,1,1,1,1,2,2,2,2,2,2,2,2,2,2,1,1,1,1,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,1,1,1,1,2,2,2,2,2,2,2,2,2,2,1,1,1,1,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1},
	{1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1},
	{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
};

int level2[24][40] = {
	{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
	{1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1},
	{1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1},
	{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
};

int level3[24][40] = {
	{1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,1,1,1,1,1,1,1,1,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1},
	{1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1},
	{1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1},
	{1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1},
	{1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,1,1,1,1,1,1,1,1,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1}
};

int level4[24][40] = {
	{1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1},
	{1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1},
	{1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,1,1,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1},
	{1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1},
	{1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1}
};

int level5[24][40] = {
	{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
	{1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1},
	{1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,1,1,1,2,2,2,2,2,2,2,2,2,2,1,1,1,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,1,1,1,2,2,2,2,2,2,2,2,2,2,1,1,1,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1},
	{1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1},
	{1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1},
	{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
};

#endif

#include "DarkGDK.h"
#include "levels.h"

// Playing area dimensions
const int g_width = 640;
const int g_height = 384;

// Since I have so few unique images, I'll just declare constants for the image numbers
const int CAR1 = 1;
const int CAR2 = 2;
const int PAVEMENT = 3;
const int GRASS = 4;
const int DIRT = 5;
const int ICE = 6;
// the cars use sprite numbers 1 and 2, so we start terrain tiles at 3
const int TILE_OFFSET = 3;

// friction coefficient for different types of terrain (the higher the number, the lower the friction)
const double g_iceFriction      = 100;
const double g_dirtFriction     = 50;
const double g_grassFriction    = 25;
const double g_pavementFriction = 10;

// vehicle acceleration
const double g_acceleration		= 3.00;

// player structure to hold all necessary info
struct objPlayer {
	float x, y;			// current position
	float angle;		// current heading
	float vx, vy;		// current velocity along the x and y axes, respectively
	float mx, my;		// maximum velocity along the axes
};

struct objPlayer g_player1;
struct objPlayer g_player2;

// function prototypes
void makeCars(void);
void myBox(int x1, int x2, int y1, int y2, int c1, int c2, int orientation);
void makeTerrain(void);
void semiRandomTile(int left, int top, int width, int height, int rMax, int gMax, int bMax);
void displayLevel(int ptr[24][40], int img1, int img2);
void handleInput(void);
void update(void);

// main body of the program
void DarkGDK(void) {

	dbSetDisplayMode(640, 384, 32);
	dbSetWindowTitle("Dark GDK Challenge 1 - Indy 500 (Atari 1978)");

	dbSyncOn();
	dbSyncRate(60);

	makeCars();
	makeTerrain();

	dbColorBackdrop(0);

	g_player1.x = 480;
	g_player1.y = 336;
	g_player1.angle = 180;

	while (LoopGDK()) {
//		displayLevel(level3, DIRT, GRASS);
//		displayLevel(level1, ICE, DIRT);
		displayLevel(level5, ICE, PAVEMENT);
//		dbSprite(CAR1, 31*16, (18*16) + 4, CAR1);
//		dbSprite(CAR2, 31*16, (20*16) + 12, CAR2);

		handleInput();
		update();

		dbSync();
	}

	return;  // end the program properly
}

/******************************************************************************
* This makes our cool little indy cars.
******************************************************************************/
void makeCars(void) {
	int c1, c2;

	// make the tires
	c1 = dbRGB(32, 32, 32);
	c2 = dbRGB(64, 64, 64);

	myBox(0, 0, 12, 8, c1, c2, 0);
	myBox(16, 0, 28, 8, c1, c2, 0);
	myBox(0, 24, 12, 32, c1, c2, 0);
	myBox(16, 24, 28, 32, c1, c2, 0);

	// make the axles
	c1 = dbRGB(64, 64, 64);
	c2 = dbRGB(128, 128, 128);

	myBox(4, 8, 8, 12, c1, c2, 0);
	myBox(20, 8, 24, 12, c1, c2, 0);
	myBox(4, 20, 8, 24, c1, c2, 0);
	myBox(20, 20, 24, 24, c1, c2, 0);

	// make the body of the blue car and get the image
	c1 = dbRGB(0, 0, 96);
	c2 = dbRGB(0, 0, 192);
	myBox(2, 12, 32, 20, c1, c2, 1);
	dbGetImage(CAR1, 0, 0, 32, 32);

	// make the body of the red car and get the image
	c1 = dbRGB(96, 0, 0);
	c2 = dbRGB(192, 0, 0);
	myBox(2, 12, 32, 20, c1, c2, 1);
	dbGetImage(CAR2, 0, 0, 32, 32);
}
/******************************************************************************
* Draw a two boxes drawn seamlessly together with gradients radiating from a
* center line to simulate a round shape.
******************************************************************************/
void myBox(int x1, int y1, int x2, int y2, int c1, int c2, int orientation) {
	int mid;

	// an orientation of 0 results in a gradient that runs left to right
	if (orientation == 0) {
		mid = ((x2 - x1) / 2) + x1;
		dbBox(x1, y1, mid, y2, c1, c1, c2, c2);
		dbBox(mid, y1, x2, y2, c2, c2, c1, c1);
	// while an orientation of 1 results in a gradient that runs top to bottom
	} else {
		mid = ((y2 - y1) / 2) + y1;
		dbBox(x1, y1, x2, mid, c2, c1, c2, c1);
		dbBox(x1, mid, x2, y2, c1, c2, c1, c2);
	}
}

/******************************************************************************
* Make all of the appropriate terrain tiles
******************************************************************************/
void makeTerrain(void) {
	semiRandomTile(32, 0, 16, 16, 32, 32, 32);
	dbGetImage(PAVEMENT, 32, 0, 48, 16);

	semiRandomTile(48, 0, 16, 16, 0, 128, 0);
	dbGetImage(GRASS, 48, 0, 64, 16);

	semiRandomTile(64, 0, 16, 16, 128, 64, 0);
	dbGetImage(DIRT, 64, 0, 80, 16);

	semiRandomTile(80, 0, 16, 16, 128, 128, 255);
	dbGetImage(ICE, 80, 0, 96, 16);
}

/******************************************************************************
* This makes a tile at a specific location, in the specified color with
* variations in the saturation level.
******************************************************************************/
void semiRandomTile(int left, int top, int width, int height, int rMax, int gMax, int bMax) {
	double red, green, blue;
	int sat;
	
	// convert all of our color values to a number between 0.0 and 1.0
	red = rMax / 255.0;
	green = gMax / 255.0;
	blue = bMax / 255.0;

	// place dots of random saturation levels all throughout our tile
	for (int y = 0; y < height; y++) {
		for (int x = 0; x < width; x++) {
			// pick a saturation level between 50-100% (RGB values of 128-255)
			sat = dbRnd(127) + 128;
			dbInk(dbRGB(red * sat, green * sat, blue * sat), 0);
			dbDot(x + left, y + top);
		}
	}
}

/******************************************************************************
* Step through the array in question and draw the sprites using the given
* images.  This allows us to easily use the same basic level with multiple
* terrain types.
******************************************************************************/
void displayLevel(int ptr[24][40], int img1, int img2) {
	int i = TILE_OFFSET;
	for (int y = 0; y < 24; y++) {
		for (int x = 0; x < 40; x++) {
			if (ptr[y][x] == 2) {
				dbSprite(i, x*16, y*16, img1);
			} else {
				dbSprite(i, x*16, y*16, img2);
			}
			i++;
		}
	}
}

void handleInput(void) {
	g_player1.mx = 0.0; g_player1.my = 0.0;
	
	// rotate the player's car clockwise
	if (dbRightKey() == 1) { g_player1.angle = dbWrapValue(g_player1.angle + 2); }

	// rotate the player's car counter-clockwise
	if (dbLeftKey() == 1) { g_player1.angle = dbWrapValue(g_player1.angle - 2); }

	// accelerate the car to it's maximum velocity -- restrict each component to the maximum velocity allowed
	if (dbUpKey() == 1) {
		// calculate the x component
		g_player1.mx = g_acceleration * dbCos(g_player1.angle);
		// calculate the y component
		g_player1.my = g_acceleration * dbSin(g_player1.angle);

//		g_player1.vx = g_player1.mx;
//		g_player1.vy = g_player1.my;

		// only modify our current velocity upwards
		if (abs(g_player1.mx) > abs(g_player1.vx)) { g_player1.vx = g_player1.mx; }
		if (abs(g_player1.my) > abs(g_player1.vy)) { g_player1.vy = g_player1.my; }
	}
}

void update(void) {
	int sprite, terrain;
	float mag;

	// adjust the player's position based on the current movement vector
	g_player1.x = g_player1.x + g_player1.vx;
	g_player1.y = g_player1.y + g_player1.vy;

	// wrap around the edges of the playing area
	if (g_player1.x > g_width) { g_player1.x -= g_width; }
	if (g_player1.x < 0) { g_player1.x += g_width; }
	if (g_player1.y > g_height) { g_player1.y -= g_height; }
	if (g_player1.y < 0) { g_player1.y += g_height; }

	dbSprite(CAR1, g_player1.x, g_player1.y, CAR1);
	dbOffsetSprite(CAR1, 16, 16);
	dbRotateSprite(CAR1, g_player1.angle);

	sprite = dbSpriteCollision(CAR1, 0);
	terrain = dbSpriteImage(sprite);
	// adjust the x and y components of the player's velocity using the correct friction value
	switch (terrain) {
		case ICE:
			g_player1.vx = dbCurveValue(0.0, g_player1.vx, g_iceFriction);
			g_player1.vy = dbCurveValue(0.0, g_player1.vy, g_iceFriction);
			break;
		case DIRT:
			g_player1.vx = dbCurveValue(0.0, g_player1.vx, g_dirtFriction);
			g_player1.vy = dbCurveValue(0.0, g_player1.vy, g_dirtFriction);
			break;
		case GRASS:
			g_player1.vx = dbCurveValue(0.0, g_player1.vx, g_grassFriction);
			g_player1.vy = dbCurveValue(0.0, g_player1.vy, g_grassFriction);
			break;
		case PAVEMENT:
			g_player1.vx = dbCurveValue(0.0, g_player1.vx, g_pavementFriction);
			g_player1.vy = dbCurveValue(0.0, g_player1.vy, g_pavementFriction);
			break;
		default:
			g_player1.vx = 0;
			g_player1.vy = 0;
	}

	// if our velocity vector is less than our current maximum, adjust it to our maximum
	if (abs(g_player1.vx) < abs(g_player1.mx)) { g_player1.vx = g_player1.mx; }
	if (abs(g_player1.vy) < abs(g_player1.my)) { g_player1.vy = g_player1.my; }
}

#include "DarkGDK.h"

// structure for a fog sprite info
struct objPlate {
	int x, y, angle;
	int dx, dy;
};

struct objPlate plates[1000];

// image numbers for our fog and our logo
int g_fog   = 1;
int g_logo  = 2;

int g_alpha = 0;

void initFogSprites(void);
void initLogo(void);
void update(void);

// the main entry point for the application is this function
void DarkGDK ( void )
{
	// set the display mode and go full screen
	dbSetWindowLayout(0, 0, 0);
	dbMaximizeWindow();

	// we don't want the mouse disrupting our cool effects
	dbHideMouse();

	// turn on sync rate and set maximum rate to 60 fps
	dbSyncOn();
	dbSyncRate(60);

	// initialize everything
	initFogSprites();
	initLogo();

	// blue doesn't make a cool backdrop, so make it black
	dbColorBackdrop(0);

	// our main loop
	while (LoopGDK()) {
		// update the screen
		update();
		dbSync();
	}

	// return back to windows
	return;
}

/******************************************************************************
* Create a bitmap to use as a workspace, make our randomized fog sprite,
* then clean up after ourselves.
******************************************************************************/
void initFogSprites(void) {
	int i, x, y, color;

	// create the image for our fog sprites
	dbCreateBitmap(1, 512, 64);
	dbSetCurrentBitmap(1);
		// place random pixels of grey all over our fog plate
		for (y = 0; y < 64; y++) {
			for (x = 0; x < 512; x++) {
				color = dbRnd(255);
				dbInk(dbRGB(color, color, color), 0);
				dbDot(x, y);
			}
		}

		// get the image for our fog sprites
		dbGetImage(g_fog, 0, 0, 512, 64);
	// bitmap workspace no longer needed so set current back to screen
	dbSetCurrentBitmap(0);
	// and delete the workspace/bitmap
	dbDeleteBitmap(1);

	// set up the fog plates at random locations and angles
	for (i=0; i<1000; i++) {
		plates[i].x = dbRnd(480) + 80;
		plates[i].y = dbRnd(400) + 40;
		plates[i].angle = dbRnd(359);
		plates[i].dx = dbRnd(4) - 2;
		plates[i].dy = dbRnd(4) - 2;
	}
}

/******************************************************************************
* Create a bitmap to use as a workspace, make our logo sprite, then clean up
* after ourselves.
******************************************************************************/
void initLogo(void) {
	dbCreateBitmap(1, 640, 480);
	dbSetCurrentBitmap(1);
		// write text in black, but not transparent black
		dbInk(dbRGB(1, 1, 1), 0);
		dbSetTextFont("ComicSans");
		dbSetTextToBold();
		dbSetTextSize(80);
		dbCenterText(320, 120, "Dark GDK");
		dbCenterText(320, 240, "Coding Challenge");

		// get the image for our logo
		dbGetImage(g_logo, 0, 0, 640, 480);
	dbSetCurrentBitmap(0);
	dbDeleteBitmap(1);
}

/******************************************************************************
* Update all of the sprites
******************************************************************************/
void update(void) {
	int i, spr;

	for (i=0; i<1000; i++) {
		// valid sprite numbers are 1 and up
		spr = i + 1;

		// place a fog sprite at the proper location and orientation
		dbSprite(spr, plates[i].x, plates[i].y, g_fog);
		dbRotateSprite(spr, plates[i].angle);

		// make the sprite see-through so that it becomes believable
		dbSetSpriteAlpha(spr, 3);

	    // update the sprites position for the next update
		plates[i].x = plates[i].x + plates[i].dx;
		plates[i].y = plates[i].y + plates[i].dy;

		// if the sprite hits the edge of the screen, reverse its direction
		if ((plates[i].x < 0) || (plates[i].x > 640)) {
			plates[i].dx = -plates[i].dx;
			plates[i].x = plates[i].x + (2 * plates[i].dx);
		}
		if ((plates[i].y < 0) || (plates[i].y > 480)) {
			plates[i].dy = 0 - plates[i].dy;
			plates[i].y = plates[i].y + (2 * plates[i].dy);
		}
	}

	// draw the logo last so that it is drawn over the fog
	spr += 1;
	dbSprite(spr, 0, 0, g_logo);
	dbSetSpriteAlpha(spr, g_alpha);

	// adjust the logo's alpha value so that it slowly fades into view
	if (g_alpha < 128) {
		g_alpha += 1;
	}
}

#include "DarkGDK.h"

// image numbers
const int g_logo  = 1;
const int g_jet   = 2;
const int g_bar   = 3;
const int g_blind = 4;

// sprite offsets used in the jetUpdate() function
const int g_jetOffsetX = 86;
const int g_jetOffsetY = 28;

// it's still black, just not the transparent kind
int g_black = dbRGB(1, 1, 1);

// function prototypes
void drawJet(void);
void initJets(void);
void initLogo(void);
void updateJet(int index, int dx);

// our jet structure
struct objJet {
	int x, y, angle;	// coordinates and orientation of our jet
	int spr, blind;		// indeces for our sprites
	int bx, by;			// coordinates for the jets associated blind
};

struct objJet jets[4];

// the main entry point for the application is this function
void DarkGDK(void) {
	// turn on sync rate and set maximum rate to 60 fps
	dbSetWindowLayout(0, 0, 0);
	dbMaximizeWindow();

	dbSyncOn();
	dbSyncRate(60);

	// perform the setup
	drawJet();
	initLogo();
	initJets();

	// get rid of the blue background
	dbColorBackdrop(g_black);

	// our main loop
	while (LoopGDK()) {
		dbSprite(1, 0, 0, g_logo);
		dbSprite(2, 0, 32, g_bar);
		dbSprite(3, 0, 384, g_bar);

		// make jets 0 and 2 fly left-to-right, revealing bits of our logo
		updateJet(0, 1);
		updateJet(2, 1);

		// make jets 1 and 3 fly right-to-left, revealing the rest of our logo
		updateJet(1, -1);
		updateJet(3, -1);

		// update the screen
		dbSync();
	}

	// return back to windows
	return;
}

/******************************************************************************
* Create a bitmap and then perform an elaborate line drawing of a jet.
******************************************************************************/
void drawJet(void) {
	dbCreateBitmap(1, 87, 28);
	dbSetCurrentBitmap(1);
		dbCLS(g_black);

		// Step 1: Draw the top half of the image

		// outline
		dbInk(dbRGB(128, 128, 128), g_black);
		dbLine(1,  27, 9,  25);
		dbLine(10, 24, 38, 24);
		dbLine(39, 25, 52, 28);
		dbLine(30, 24, 77, 0);
		dbLine(77, 0,  77, 19);
		dbLine(59, 21, 82, 19);
		dbLine(82, 19, 82, 28);
		dbLine(82, 20, 86, 20);
		dbLine(86, 20, 86, 28);

		// cockpit
		dbInk(dbRGB(128, 128, 192), g_black);
		dbLine(15, 26, 32, 26);
		dbLine(14, 27, 32, 27);

		// Step 2: Copy what we've drawn to a new bitmap
		dbCreateBitmap(2, 87, 56);
		dbSetCurrentBitmap(2);
			dbCopyBitmap(1, 1, 0, 87, 28, 2, 1, 0, 87, 28);

			// Step 3: Vertically flip what we've drawn
			dbFlipBitmap(1);

			// Step 4: Copy it to complete the image of the jet
			dbCopyBitmap(1, 1, 0, 87, 28, 2, 1, 28, 87, 56);

			// Step 5: Get the finished jet image
			dbGetImage(g_jet, 0, 0, 87, 56);
		dbSetCurrentBitmap(0);
		dbDeleteBitmap(2);
	dbDeleteBitmap(1);
}

/******************************************************************************
* Create a bitmap to use as a workspace, make our logo sprite, then clean up
* after ourselves.
******************************************************************************/
void initLogo(void) {
	dbCreateBitmap(1, 640, 480);
	dbSetCurrentBitmap(1);
		// clear the image to the appropriate color
		dbCLS(g_black);

		// get the image for the blind to block out things we don't want seen
		dbGetImage(g_blind, 0, 0, 640, 120);

		// write text in black, but not transparent black
		dbInk(dbRGB(128, 128, 128), g_black);
		dbSetTextFont("ComicSans");
		dbSetTextToBold();
		dbSetTextSize(80);

		// draw the text for our logo
		dbCenterText(320, 120, "Dark GDK");
		dbCenterText(320, 240, "Coding Challenge");

		// get the image for our logo
		dbGetImage(g_logo, 0, 0, 640, 480);
	dbSetCurrentBitmap(0);
	dbDeleteBitmap(1);

	// get the image for the cheesy blue bars
	dbCreateBitmap(1, 640, 32);
	dbSetCurrentBitmap(1);
		dbCLS(dbRGB(0, 0, 128));
		dbGetImage(g_bar, 0, 0, 640, 32);
	dbSetCurrentBitmap(0);
	dbDeleteBitmap(1);
}

/******************************************************************************
* Initialize the information for our jets -- used to do the fly-by
* If you want to play around with it, the easiest way is to change the
* x values, but stay within the constraints used in the updateJet() function
* (-200, 800) to avoid strange behavior.
******************************************************************************/
void initJets(void) {
	jets[0].x = -170;
	jets[0].y = 48;
	jets[0].angle = 180;
	jets[0].spr = 4;
	jets[0].blind = 5;
	jets[0].bx = 0;
	jets[0].by = 0;

	jets[1].x = 690;
	jets[1].y = 160;
	jets[1].angle = 0;
	jets[1].spr = 6;
	jets[1].blind = 7;
	jets[1].bx = 0;
	jets[1].by = 120;

	jets[2].x = -100;
	jets[2].y = 280;
	jets[2].angle = 180;
	jets[2].spr = 8;
	jets[2].blind = 9;
	jets[2].bx = 0;
	jets[2].by = 240;

	jets[3].x = 790;
	jets[3].y = 400;
	jets[3].angle = 0;
	jets[3].spr = 10;
	jets[3].blind = 11;
	jets[3].bx = 0;
	jets[3].by = 360;
}

/******************************************************************************
* Move the given jet in the appropriate direction, adjusting the blinds as
* we go.
******************************************************************************/
void updateJet(int index, int dx) {
	// draw the blinds
	dbSprite(jets[index].blind, jets[index].bx, jets[index].by, g_blind);

	// if the jets are in the "action" area
	if ((jets[index].x > -200) && (jets[index].x < 800)) {
		// adjust by our delta x (can be positive or negative)
		jets[index].x += dx;
		dbSprite(jets[index].spr, jets[index].x, jets[index].y, g_jet);

		// turn the jet so it is facing the direction it is traveling
		dbRotateSprite(jets[index].spr, jets[index].angle);

		// offset the jet sprite to help the blinds uncover our logo cleanly
		dbOffsetSprite(jets[index].spr, g_jetOffsetX, g_jetOffsetY);

		// if the jet is onscreen, move the appropriate blind
		if ((jets[index].x > 0) && (jets[index].x < 640)){
			jets[index].bx += dx;
		}
	}
}

#include "DarkGDK.h"

// our globals -- these are both image numbers and object/sprite numbers respectively
const int g_backdrop = 1;
const int g_logo     = 2;

// function prototypes
void makeBackdrop(void);
void makeLogo(void);

// the main entry point for the application is this function
void DarkGDK(void) {
	// go fullscreen
	dbSetWindowLayout(0, 0, 0);
	dbMaximizeWindow();

	// turn on sync rate and set maximum rate to 60 fps
	dbSyncOn();
	dbSyncRate(60);

	// hide the mouse and disable the autocam feature
	// -- we'll be using a single 3D element with this example and we don't want the camera moving around
	dbHideMouse();
	dbAutoCamOff();

	// initialize everything
	makeBackdrop();
	makeLogo();

	// our main loop
	while (LoopGDK()) {
		dbScrollObjectTexture(g_backdrop, 0.01, 0);
		dbSprite(g_logo, 0, 0, g_logo);
		// update the screen
		dbSync();
	}

	// return back to windows
	return;
}
/******************************************************************************
* This creates the texture and the plane object used as the backdrop for our
* logo.
******************************************************************************/
void makeBackdrop(void) {
	// create a "workspace" bitmap for our texture
	dbCreateBitmap(1, 512, 512);
	//not required -- apparently dbCreateBitmap() sets it for us
	//dbSetCurrentBitmap(1);

	// create an interesting color effect and make it seamless
	for (int r = 0; r < 256; r++) {
		for (int b = 255; b >= 0; b--) {
			dbInk(dbRGB(r, 0, b), 0);
			dbDot(r, b);
			// the next three commands mirror the effect so that the texture is seamless
			dbDot(511-r, b);
			dbDot(r, 511-b);
			dbDot(511-r, 511-b);
		}
	}

	// get the texture image
	dbGetImage(g_backdrop, 0, 0, 512, 512);

	dbSetCurrentBitmap(0);
	dbDeleteBitmap(1);

	// make our backdrop (a 3D object)
	dbMakeObjectPlain(g_backdrop, 640, 480);
	dbTextureObject(g_backdrop, g_backdrop);

	// this position should cause the object to completely fill the screen and no more
	// found through trial and error
	dbPositionObject(g_backdrop, -0.5, 0.5, 400);
}

/******************************************************************************
* This creates the image used for our logo sprite.
******************************************************************************/
void makeLogo(void) {
	int i;

    char *msg  = "DarkGDK DarkGDK DarkGDK DarkGDK DarkGDK DarkGDK DarkGDK DarkGDK DarkGDK DarkGDK";
	char *msg2 = "DarkGDK DarkGDK                                                 DarkGDK DarkGDK";

	dbCreateBitmap(1, 640, 480);
	// flood the bitmap with a non-transparent black color
	dbCLS(dbRGB(1, 1, 1));

	// make our drawing text be the transparent black so we can see through the text
	dbInk(0, dbRGB(1, 1, 1));
	
	// make a patterned background for our logo that says "Dark GDK" all over it
	for (i=0;  i<6;  i++){ dbText(0, i*20, msg); }
	for (i=6;  i<10; i++){ dbText(0, i*20, msg2); }
	for (i=10; i<12; i++){ dbText(0, i*20, msg); }
	for (i=17; i<24; i++){ dbText(0, i*20, msg); }

	// display the main part of the logo
	dbSetTextSize(80);
	dbCenterText(320, 120, "Dark GDK");
	dbCenterText(320, 244, "Coding Challenge");

	dbGetImage(g_logo, 0, 0, 640, 480);

	dbSetCurrentBitmap(0);
	dbDeleteBitmap(1);
}

#include "DarkGDK.h"

//constants
const int g_bg = 101;
const int g_field1 = 101;
const int g_field2 = 102;

// the indexes for our logo sprites
int g_logo[8];

//function prototypes
void createBackground(void);
void manageBackground(void);
void createLogo(void);
void makeLogo(int color, int index);
void manageLogo(void);

/******************************************************************************
* the main entry point for the application is this function
******************************************************************************/
void DarkGDK(void) {
	// determines how often to cycle our logo sprites
	int counter = 0;

	dbSetWindowLayout(0, 0, 0);
	dbMaximizeWindow();

	// turn on sync rate and set maximum rate to 60 fps
	dbSyncOn();
	dbSyncRate(60);

	dbHideMouse();
	dbAutoCamOff();

	createBackground();
	createLogo();

	dbColorBackdrop(0);

	// our main loop
	while (LoopGDK()) {
		// update the background
		manageBackground();

		// every ten frames update the logos
		if (counter < 10) {
			counter++;
		} else {
			manageLogo();
			counter = 0;
		}

		// update the screen
		dbSync();
	}

	// return back to windows
	return;
}

/******************************************************************************
* Makes our starfields
******************************************************************************/
void createBackground(void) {
	int i, r, g, b, x, y;

	dbCreateBitmap(1, 512, 512);

	// create our starfield texture
	for (i=0; i<2000; i++) {
		r = dbRnd(127) + 128;
		g = dbRnd(127) + 128;
		b = dbRnd(127) + 128;

		dbInk(dbRGB(r, g, b), 0);
		dbDot(dbRnd(511), dbRnd(511));
	}

	dbGetImage(g_bg, 0, 0, 512, 512);

	dbSetCurrentBitmap(0);
	dbDeleteBitmap(1);

	// create the distant starfield
	dbMakeObjectPlain(g_field1, 640, 480);
	dbTextureObject(g_field1, g_bg);
	dbPositionObject(g_field1, -0.5, 0.5, 400);

	// makes the texture repeat across the surface
	dbScaleObjectTexture(g_field1, 4, 4);

	// create the near starfield
	dbMakeObjectPlain(g_field2, 320, 240);
	dbTextureObject(g_field2, g_bg);
	dbPositionObject(g_field2, -0.25, 0.25, 200);

	// makes the starfield transparent
	dbSetObjectTransparency(g_field2, 3);
}

/******************************************************************************
* Makes our starfields move
******************************************************************************/
void manageBackground(void) {
	dbScrollObjectTexture(g_field1, 0, -0.0001);
	dbScrollObjectTexture(g_field2, 0, -0.001);
}

/******************************************************************************
* Make eight (8) logos in different colors
******************************************************************************/
void createLogo(void) {
	dbSetTextFont("ComicSans");
	dbSetTextSize(80);

	makeLogo(dbRGB(255, 0, 0), 1);
	makeLogo(dbRGB(255, 128, 0), 2);
	makeLogo(dbRGB(255, 255, 0), 3);
	makeLogo(dbRGB(0, 255, 0), 4);
	makeLogo(dbRGB(0, 0, 255), 5);
	makeLogo(dbRGB(96, 0, 255), 6);
	makeLogo(dbRGB(128, 0, 255), 7);
	makeLogo(dbRGB(255, 255, 255), 8);

	// initialize our reference array
	for (int i = 0; i<8; i++) {
		g_logo[i] = i+1;
	}
}

/******************************************************************************
* Makes an individual logo in the given color
******************************************************************************/
void makeLogo(int color, int index) {
	dbInk(color, 0);
	dbCenterText(320, 120, "Dark GDK");
	dbCenterText(320, 240, "Coding Challenge");
	dbGetImage(index, 0, 0, 640, 480);
	
	dbMakeObjectPlain(index, 160, 120);
	dbTextureObject(index, index);
	dbSetObjectTransparency(index, 3);
}

/******************************************************************************
* Display the logos and cycle through them each update
******************************************************************************/
void manageLogo(void) {
	int i;
	float offset;

	for(i = 0; i < 8; i++) {
		offset = i * 0.25;
		// position the current logo a little off from the previous one
		dbPositionObject(g_logo[i], offset, offset, 100 + offset);

		// effectively shifts/rotates the array of logos
		g_logo[i] += 1;
		if (g_logo[i] > 8) { g_logo[i] = 1; }
	}
}

#include "DarkGDK.h"

// these constants are used to reference both the objects and their textures
const int g_logo   = 1;
const int g_globe  = 2;
const int g_clouds = 3;

// this is the size for our globe and cloud textures
// Note: This must be a power of 2 or the initTerrain() and divide() functions
// will not work properly!  The functions really should check this to make
// sure a valid value has been passed to them.
const int g_size   = 256;

// angles to rotate our objects by
float g_logo_angle  = 0.0;
float g_globe_angle = 0.0;
float g_cloud_angle = 180.0;

// our workspace to create our world terrain and cloud cover
int g_terrain[g_size][g_size];

// function prototypes
void initLogo(void);
void initWorld(void);
void initTerrain(void);
void divide(int x, int y, int size, int c1, int c2, int c3, int c4);
void update(void);

/******************************************************************************
* the main entry point for the application is this function
******************************************************************************/
void DarkGDK(void) {
	// turn on sync rate and set maximum rate to 60 fps
	dbSyncOn();
	dbSyncRate(60);

	// go into fullscreen mode -- this works better than dbSetWindowOff()
	dbSetWindowLayout(0, 0, 0);
	dbMaximizeWindow();

	// get rid of our mouse cursor
	dbHideMouse();

	// this ensures we have the same terrain every time
	// original value: 19 -- check out 7 and 15 for some interesting results
	dbRandomize(19);

	// initialize everything -- notice we don't call initTerrain() directly
	initLogo();
	initWorld();

	// set the backdrop to black instead of the "burns my eyes" blue
	dbColorBackdrop(0);

	// our main loop
	while (LoopGDK()) {

		update();

		// update the screen
		dbSync();
	}

	// return back to windows
	return;
}

/******************************************************************************
* Create a bitmap to use as a workspace, make our logo sprite, then clean up
* after ourselves.  For the most part this function should look familiar.
******************************************************************************/
void initLogo(void) {
	dbCreateBitmap(1, 640, 640);
		// write text in black, but not transparent black
		dbInk(dbRGB(255, 255, 255), 0);
		dbSetTextFont("ComicSans");
		dbSetTextToBold();
		dbSetTextSize(80);
		dbCenterText(320, 120, "Dark GDK");
		dbCenterText(320, 240, "Coding Challenge");

		// get the image for our logo
		dbGetImage(g_logo, 0, 0, 640, 480);
	dbSetCurrentBitmap(0);
	dbDeleteBitmap(1);

	/************************************************
	* make a cylinder object to display our logo on
	************************************************/
	dbMakeObjectCylinder(g_logo, 2.25);
	dbTextureObject(g_logo, g_logo);
	// make the cylinder transparent so the black areas aren't drawn
	dbSetObjectTransparency(g_logo, 3);
}

/******************************************************************************
* Reposition the logo, the globe and the clouds to the current angles then
* update the angles for next time.
******************************************************************************/
void update(void) {
	// rotate the objects
	dbYRotateObject(g_logo, g_logo_angle);
	dbYRotateObject(g_globe, g_globe_angle);
	dbYRotateObject(g_clouds, g_cloud_angle);

	// update the angles to rotate them by
	g_logo_angle  = dbWrapValue(g_logo_angle + 1);
	g_globe_angle = dbWrapValue(g_globe_angle - 0.5);
	g_cloud_angle = dbWrapValue(g_cloud_angle - 0.75);
}

/******************************************************************************
* Initializes the globe and the cloud cover -- calls initTerrain() to help
* build the textures for each
******************************************************************************/
void initWorld(void) {
	int x, y;
	int c;		// used to represent a color component throughout this function
	int p;		// used to determine if we are close to the North or South pole

	// create our workspace bitmap in the desired size
	dbCreateBitmap(1, g_size, g_size);
		// initialize the terrain map
		initTerrain();

		// paint our terrain texture based on the terrain map
		// and proximity to the poles
		for (y = 0; y < g_size; y++) {
			for (x = 0; x < g_size; x++) {
				// our baseline for the poles starts here
				p = g_size / 8;

				// but to keep it from being too uniform, we'll add a random
				// amount to it
				p = dbRnd(p) + p;

				// now check to see if we're at one of the poles based on our
				// new (p)olar proximity value
				if ((y < p) || (y > (g_size - p))) {
					// if we are near the poles set our secondary color
					// component (c) to a substantial value
					c = 192;
				} else {
					// otherwise set the secondary color component to 0
					c = 0;
				}

				// if our terrain map value at this point is less than
				// 192 we'll assume that it is water
				if (g_terrain[x][y] < 192) {
					dbInk(dbRGB(c, c, g_terrain[x][y]), 0);
				}
				// otherwise we'll assume we're over land
				else {
					dbInk(dbRGB(c, g_terrain[x][y]-64, c), 0);
				}
				// now place a single dot in the chosen color
				dbDot(x, y);
			}
		}

		// get the image for our global texture
		dbGetImage(g_globe, 0, 0, g_size, g_size);

		// clear our workspace so we can create our cloud cover
		dbCLS(dbRGB(0, 0, 0));

		// use the existing terrain map to make our clouds
		for (y = 0; y < g_size; y++) {
			for (x = 0; x < g_size; x++) {
				if (g_terrain[x][y] < 170) {
					c = dbRnd(63) + 192;
					dbInk(dbRGB(c, c, c), 0);
					dbDot(x, y);
				}
			}
		}

		// get the image for our logo
		dbGetImage(g_clouds, 0, 0, g_size, g_size);
	dbSetCurrentBitmap(0);
	dbDeleteBitmap(1);

	// make our globe and texture it
	dbMakeObjectSphere(g_globe, 2.0);
	dbTextureObject(g_globe, g_globe);

	// make our cloud sphere (slightly bigger than the globe) and texture it
	dbMakeObjectSphere(g_clouds, 2.075);
	dbTextureObject(g_clouds, g_clouds);

	// use this command as opposed to dbSetTransparency() so that we can see
	// through the clouds themselves, not just through the black areas of
	// the texture
	dbGhostObjectOn(g_clouds);
}

/******************************************************************************
* Sets the 4 corners of the terrain at random, then calls the recursive
* function that will build the rest of the texture.
******************************************************************************/
void initTerrain(void) {
	// randomly choose values for the four corners
	int c1 = dbRnd(255);
	int c2 = dbRnd(255);
	int c3 = dbRnd(255);
	int c4 = dbRnd(255);

	g_terrain[0][0]					= c1;
	g_terrain[g_size-1][0]			= c2;
	g_terrain[0][g_size-1]			= c3;
	g_terrain[g_size-1][g_size-1]	= c4;

	// make our terrain based on these four corners
	divide(0, 0, g_size, c1, c2, c3, c4);
}

/******************************************************************************
* This is a recursive function (meaning it calls itself).  The logic behind
* this function is to work on smaller and smaller pieces of the whole terrain
* cutting each piece into quarters until it only has one unit to work on.
* Along the way, it is making changes to the middle value, randomizing it
* so that we end up with a diverse landscape.  This is basically a simplified
* version of the "Midpoint Displacement" algorithm.
*
* The principles of recursion can be confusing to newcomers.  If you have any
* questions, please feel free to ask.  I'm not an expert, but I'll try to help.
******************************************************************************/
void divide(int x, int y, int size, int c1, int c2, int c3, int c4) {
	int color;
	int edge1, edge2, edge3, edge4, center;

	// When we cut the current piece into quarters, we divide our size
	// by two.  This value represents the length of an edge as opposed to
	// the area of the new piece
	int newSize  = size / 2;

	int displacement = dbRnd(96) - 48; // generate a random number from -48 to 48

	if (size > 1) {
		// average the points along each edge to get the midpoints on the edges
		edge1 = (c1 + c2) / 2;
		edge2 = (c2 + c3) / 2;
		edge3 = (c3 + c4) / 2;
		edge4 = (c4 + c1) / 2;

		// average the 4 corners to get our center, plus modify it a bit with our random displacement
		center = ((c1 + c2 + c3 + c4) / 4) + displacement;

		// make sure that our random addition doesn't send us outside our acceptable range (0-255)
		if (center > 255) {
			center = 255;
		} else if (center < 0) {
			center = 0;
		}

		// repeat for the four smaller grids we've defined with our new points
		divide(x, y, newSize, c1, edge1, center, edge4);
		divide(x + newSize, y, newSize, edge1, c2, edge2, center);
		divide(x, y + newSize, newSize, edge4, center, edge3, c4);
		divide(x + newSize, y + newSize, newSize, center, edge2, c3, edge3);
	}
	else {	// this is our "stop case" where we're down to a single unit in the terrain grid
		color = (c1 + c2 + c3 + c4) / 4;
		g_terrain[x][y] = color;
	}
}

#include "DarkGDK.h"

// constants
const int g_logo     = 1;
const int g_texture  = 2;
const int g_roadSign = 3;
const int g_post     = 4;

// matrix number
const int g_highway = 1;

// amount to move the sign and the highway each cycle
const float g_speed = 1.0;

// z values used for our road and sign
float g_zOffset = 0;
float g_signZ = 600;

// function prototypes
void initLogo(void);
void makeTextures(void);
void semiRandomTile(int left, int top, int width, int height, int rMax, int gMax, int bMax);
void makeHighway(void);
void makeRoadSign(void);

/******************************************************************************
* the main entry point for the application is this function
******************************************************************************/
void DarkGDK(void) {
	int color;

	// turn on sync rate and set maximum rate to 60 fps
	dbSyncOn();
	dbSyncRate(60);

	// go full screen, hide the mouse and disable the autocam feature
	dbSetWindowLayout(0, 0, 0);
	dbMaximizeWindow();
	dbHideMouse();
	dbAutoCamOff();

//	int start = dbTimer();

	// initialize all of our media
	initLogo();
	makeTextures();
	makeHighway();
	makeRoadSign();

//	int end = dbTimer();

	// set our sky and fog color
	color = dbRGB(64, 64, 128);

	// if fog is available, enable fog
	if (dbFogAvailable() == 1) {
		dbFogOn();
		dbFogColor(color);
		dbFogDistance(300);
	}

	// color the backdrop and position the camera
	dbColorBackdrop(color);

	// center of the road
	dbPositionCamera(300, 3, 0);

	// American driver
//	dbPositionCamera(305, 3, 0);

	// Any other driver (I think -- Are we the only ones that drive on the "wrong" side of the road?)
//	dbPositionCamera(295, 3, 0);

	// our main loop
	while (LoopGDK()) {
		// while the sign is farther away than our planned stopping point
		if (g_signZ > 40.0) {
			// move the sign 1 step closer
			g_signZ -= g_speed;
			dbPositionObject(g_roadSign, 300, 18, g_signZ);

			// adjust the highway matrix so it looks like we're moving along it
			if (g_zOffset == -9.0) {
				// Each tile is 10.0 units deep so we'll shift the matrix every 10th
				// step.  This keeps our horizon from closing in on us and gives the
				// illusion of a never-ending road.
				dbShiftMatrixDown(g_highway);
				g_zOffset = 0.0;
			} else {
				// this slides the matrix back and forth to give the illusion of fluid motion
				g_zOffset -= g_speed;
			}
			dbPositionMatrix(g_highway, 0, 0, g_zOffset);
		}

		// You can use this to see a bit of how the matrix manipulations are working
//		dbControlCameraUsingArrowKeys(0, 5.0, 5.0);

		// use these to preview the textures we've made
//		dbSprite(g_logo, 0, 0, g_logo);			// roadsign texture
//		dbSprite(g_texture, 0, 0, g_texture);	// terrain textures

		// update the screen

//		dbText(10, 10, dbStr(end - start));
		dbSync();
	}

	// return back to windows
	return;
}

/******************************************************************************
* Create a bitmap to use as a workspace, make our logo sprite, then clean up
* after ourselves.
******************************************************************************/
void initLogo(void) {
	dbCreateBitmap(1, 640, 200);
	dbSetCurrentBitmap(1);
		// clear the image to white (to quickly make the signs white border)
		dbCLS(dbRGB(255, 255, 255));

		// change our drawing color to the green roadsign color
		dbInk(dbRGB(0, 64, 32), 0);

		// draw a box over all but our white borders
		dbBox(10, 10, 630, 190);

		// set the drawing color back to white
		dbInk(dbRGB(255, 255, 255), 0);

		// draw the text for the sign
		dbSetTextFont("ComicSans");
		dbSetTextToBold();
		dbSetTextSize(60);
		dbText(20, 30, "Dark GDK");
		dbText(20, 110, "Coding Challenge");

		// ComicSans is not a "mono-type" font so if we want these aligned easily
		// we have to do it ourselves.
		// These are supposed to by mile/kilo markers
		dbText(580, 30, "2");
		dbText(580, 110, "4");

		// get the image for our logo
		dbGetImage(g_logo, 0, 0, 640, 200);
	dbSetCurrentBitmap(0);
	dbDeleteBitmap(1);
}
/******************************************************************************
* Make all of the appropriate textures
******************************************************************************/
void makeTextures(void) {
	dbCreateBitmap(1, 512, 512);

		// pavement texture
		semiRandomTile(0, 0, 512, 256, 32, 32, 32);

		// draw the stripes on the pavement
		semiRandomTile(0, 0, 16, 256, 255, 255, 255);
		semiRandomTile(496, 0, 16, 256, 255, 255, 255);
		semiRandomTile(248, 64, 16, 128, 255, 255, 255);

		// grass texture
		semiRandomTile(0, 256, 256, 256, 0, 64, 0);

		// dirt texture
		semiRandomTile(256, 256, 256, 256, 128, 64, 0);

		// get our matrix texture image
		dbGetImage(g_texture, 0, 0, 512, 512);

	dbSetCurrentBitmap(0);
	dbDeleteBitmap(1);
}

/******************************************************************************
* This makes a tile at a specific location, in the specified color with
* variations in the saturation level.
******************************************************************************/
void semiRandomTile(int left, int top, int width, int height, int rMax, int gMax, int bMax) {
	double red, green, blue;
	int sat;
	
	// convert all of our color values to a number between 0.0 and 1.0
	red = rMax / 255.0;
	green = gMax / 255.0;
	blue = bMax / 255.0;

	// this will drastically increase performance
	dbLockPixels();
	
	// place dots of random saturation levels all throughout our tile
	for (int y = 0; y < height; y++) {
		for (int x = 0; x < width; x++) {
			// pick a saturation level between 50-100% (RGB values of 128-255)
			sat = dbRnd(127) + 128;
			dbInk(dbRGB(red * sat, green * sat, blue * sat), 0);
			dbDot(x + left, y + top);
		}
	}

	dbUnlockPixels();
}

/******************************************************************************
* Makes our highway matrix
******************************************************************************/
void makeHighway(void) {
	// make a matrix that is 600x600 units and 60x60 tiles for 10x10 tile size
	dbMakeMatrix(g_highway, 600, 600, 60, 60);

	// randomize our scenery a bit
	dbRandomizeMatrix(g_highway, 5.0);

	// cut up our matrix texture
	dbPrepareMatrixTexture(g_highway, g_texture, 2, 2);

	// set the appropriate texture for each tile
	for(int y = 0; y <= 60; y++) {
		// to the right and left of the road, we want the grass texture
		for (int x = 0; x < 28; x++) {
			dbSetMatrixTile(g_highway, x, y, 3);
			dbSetMatrixTile(g_highway, 59-x, y, 3);
		}

		// make the shoulders alongside our highway
		dbSetMatrixTile(g_highway, 28, y, 4);
		dbSetMatrixTile(g_highway, 31, y, 4);

		// make our highway
		dbSetMatrixTile(g_highway, 29, y, 1);
		dbSetMatrixTile(g_highway, 30, y, 2);

		// make sure the highway and pavement is flat
		dbSetMatrixHeight(g_highway, 28, y, 0.0);
		dbSetMatrixHeight(g_highway, 29, y, 0.0);
		dbSetMatrixHeight(g_highway, 30, y, 0.0);
		dbSetMatrixHeight(g_highway, 31, y, 0.0);
		dbSetMatrixHeight(g_highway, 32, y, 0.0);
	}
	// we have to call this to ensure our changes take effect
	dbUpdateMatrix(g_highway);
}

/******************************************************************************
* This builds our signpost
******************************************************************************/
void makeRoadSign(void) {
	// make a cylinder object and scale it to the size we need
	dbMakeObjectCylinder(g_post, 20.0);

	// scale object uses percents, so our post will be (1, 20, 1)
	dbScaleObject(g_post, 5, 100, 5);

	// turn our cylinder object into a mesh
	dbMakeMeshFromObject(g_post, g_post);

	// we don't need the original object anymore, so delete it to free the resources
	dbDeleteObject(g_post);

	// make the sign face and texture it with our sign texture
	dbMakeObjectPlain(g_roadSign, 32, 10);
	dbTextureObject(g_roadSign, g_logo);

	// add the posts to our sign
	dbAddLimb(g_roadSign, 1, g_post);
	dbAddLimb(g_roadSign, 2, g_post);

	// offset the posts to look like they're actually supporting the sign
	dbOffsetLimb(g_roadSign, 1, -15.0, -12, -1);
	dbOffsetLimb(g_roadSign, 2,  15.0, -12, -1);
}