Sorry your browser is not supported!

#include "DarkGDK.h"

/******************************************************************************
* Constants
******************************************************************************/
// textures
const int g_texParticle = 1;
const int g_texMatrix   = 2;

// matrix information
const int g_objMatrix = 1;
const int g_size = 400;
const int g_border = g_size / 2;

// number of targets
const int g_numTargets = 50;

// available target numbers to use for the g_sun and g_moon objects
const int g_sun  = g_numTargets + 1;
const int g_moon = g_numTargets + 2;

// universal target info
const int g_maxLife = 1000;
const int g_particleLife = 20;

// target object
struct sTarget {
	int obj, cycle, counter;
	float x, y, z, dx, dy, dz;
};

struct sTarget targets[g_numTargets];

// stuff for our "celestial bodies" and the light they emit
float g_sunAngle = 0;
float g_skyColor = 0.18;
float g_dAngle = 0.1;
float g_dColor = g_dAngle / 1000.0;

/******************************************************************************
* Function prototypes
******************************************************************************/
void init(void);
void makeTextures(void);
void makeWorld(void);
void makeTargets(void);
void makeLights(void);
void update(void);
void updateTargets(void);
void updateLights(void);
void semiRandomTile(int left, int top, int width, int height, int rMax, int gMax, int bMax);

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

	init();

	// our main loop
	while (LoopGDK()) {
		dbControlCameraUsingArrowKeys(0, 1.0, 5.0);
		// update the screen
		update();
		dbSync();
	}

	// return back to windows
	return;
}

/******************************************************************************
* Perform all of our initialization stuff
******************************************************************************/
void init(void) {
	// turn on sync rate and set maximum rate to 60 fps
	dbSyncOn();
	dbSyncRate(60);

	// initialize the back buffer
	dbSync();

	// hide the mouse and turn off the autocam feature
	dbHideMouse();
	dbAutoCamOff();

	// make the application fullscreen (method 1 -- this should usually work)
	dbSetWindowOff();
	// make the application fullscreen (method 2 -- use this when you have problems with method 1)
//	dbSetWindowLayout(0, 0, 0);
//	dbMaximizeWindow();

	// initialize the relevant parts of the scene
	makeTextures();
	makeWorld();
	makeTargets();
	makeLights();

	dbColorBackdrop(0);
	dbPositionCamera(0, 5, 0);
}

/******************************************************************************
* Make all of our textures
******************************************************************************/
void makeTextures(void) {
	// create a temporary workspace bitmap
	dbCreateBitmap(1, 256, 256);
		// get our particle texture
		dbInk(dbRGB(255, 255, 255), 0);
		dbBox(2, 2, 3, 3);
		dbGetImage(g_texParticle, 0, 0, 6, 6);

		// get our matrix texture
		semiRandomTile(0, 0, 256, 256, 32, 128, 64);
		dbGetImage(g_texMatrix, 0, 0, 256, 256);

	// toggle all drawing operations back to the screen (bitmap #0)
	dbSetCurrentBitmap(0);
	// delete our workspace
	dbDeleteBitmap(1);
}

/******************************************************************************
* Build our scene
******************************************************************************/
void makeWorld(void) {
	// make floor using a matrix -- I haven't figured out how to properly light a large plane
	dbMakeMatrix(g_objMatrix, g_size, g_size, 50, 50);
	dbPrepareMatrixTexture(g_objMatrix, g_texMatrix, 1, 1);
	dbSetMatrix(g_objMatrix, 0, 0, 1, 1, 1, 1, 1);
	dbPositionMatrix(g_objMatrix, -(g_size / 2), 0, -(g_size / 2));
	dbUpdateMatrix(g_objMatrix);
}

/******************************************************************************
* Make all of our target spheres and their related particle systems
******************************************************************************/
void makeTargets(void) {
	int i, r, g, b;

	for (i = 0; i < g_numTargets; i++) {
		// set the target's color
		r = (dbRnd(3) + 1) * 63;
		g = (dbRnd(3) + 1) * 63;
		b = (dbRnd(3) + 1) * 63;

		// set the targets object number
		targets[i].obj = i+1;

		// set the cycle to the "sphere" cycle
		targets[i].cycle = 1;

		// set the target's lifetime for this cycle
		targets[i].counter = dbRnd(g_maxLife);

		// set the target's starting position
		targets[i].x = dbRnd(g_size) - (g_border);
		targets[i].y = dbRnd(10) + 10;
		targets[i].z = dbRnd(g_size) - (g_border);

		// set the targets direction, disallowing values of 0
		targets[i].dx = dbRnd(1);
		if (targets[i].dx == 0) { targets[i].dx = -1; }

		targets[i].dy = (dbRnd(1)) / 10.0;
		if (targets[i].dy == 0) { targets[i].dy = -0.1; }

		targets[i].dz = dbRnd(1);
		if (targets[i].dz == 0) { targets[i].dz = -1; }

		// make the target sphere -- our visual cue as to where the targets are
		dbMakeObjectSphere(targets[i].obj, 10.0);
		dbPositionObject(targets[i].obj, targets[i].x, targets[i].y, targets[i].z);
		dbColorObject(targets[i].obj, dbRGB(r, g, b));

		// initialize the particle system for the target -- notice emissions is set to 0 for now
		dbMakeParticles(targets[i].obj, 1, 10, 10);
		dbSetParticleEmissions(targets[i].obj, 0);
		dbSetParticleSpeed(targets[i].obj, 0.01);
		dbSetParticleGravity(targets[i].obj, 2.0);
		dbColorParticles(targets[i].obj, r, g, b);
		dbPositionParticleEmissions(targets[i].obj, targets[i].x, targets[i].y, targets[i].z);
	}
}

/******************************************************************************
* Initialize all of the lights for our scene
******************************************************************************/
void makeLights(void) {
	int g_sunColor  = dbRGB(255, 255, 192);
	int g_moonColor = dbRGB(64, 64, 72);

	// setting this to 0 lets us see the effects of our lights
	dbSetAmbientLight(0);

	// make the sun light (range chosen after a bit of tinkering)
	dbSetPointLight(0, 0, g_size, 0);
	dbColorLight(0, g_sunColor);
	dbSetLightRange(0, g_size * 1000);

	// make a sphere object for our sun
	dbMakeObjectSphere(g_sun, 200);

	// snag a copy of the mesh to use as the actual sun
	dbMakeMeshFromObject(1, g_sun);

	// add the mesh as a new limb and position it at "high noon"
	dbAddLimb(g_sun, 1, 1);
	dbOffsetLimb(g_sun, 1, 0, g_size*2, 0);

	// delete the mesh
	dbDeleteMesh(1);

	// hide the base limb -- I don't know if there's a better way, but this worked
	dbHideLimb(g_sun, 0);

	// make the sun glow
	dbSetObjectEmissive(g_sun, g_sunColor);
//	dbGhostObjectOn(g_sun);

	// make our moon light
	dbMakeLight(1);
	dbSetPointLight(1, 0, g_size, 0);
	dbColorLight(1, g_moonColor);
	dbSetLightRange(1, g_size * 2);

	// make the moon object
	dbMakeObjectSphere(g_moon, 100);

	// snag a copy of the mesh to use as the actual moon
	dbMakeMeshFromObject(1, g_moon);

	// add the mesh from before as a new limb and position it at "high noon"
	dbAddLimb(g_moon, 1, 1);
	dbOffsetLimb(g_moon, 1, 0, g_size*2, 0);

	// hide the base limb -- I don't know if there's a better way, but this worked
	dbHideLimb(g_moon, 0);

	// delete the mesh
	dbDeleteMesh(1);

	// make the moon glow
	dbSetObjectEmissive(g_moon, g_moonColor);
	dbGhostObjectOn(g_moon);

	// make the player light (follows the camera)
	dbMakeLight(2);
	dbSetPointLight(2, 0, 10, 0);
	dbColorLight(2, dbRGB(0, 64, 255));
	dbSetLightRange(2, 40);
}

/******************************************************************************
* Calls the other update functions -- I just wrote this to clean up the
* game loop a bit -- for speed purposes, I would remove it in the future.
******************************************************************************/
void update(void) {
	updateTargets();
	updateLights();
}

/******************************************************************************
* Update the targets every cycle
******************************************************************************/
void updateTargets(void) {
	int i;
	float x, z, angle;

	// update each one of the targets
	for (i = 0; i < g_numTargets; i++) {

		// modify the target's position based on the direction modifiers
		targets[i].x += targets[i].dx;
		targets[i].y += targets[i].dy;
		targets[i].z += targets[i].dz;

		// if the target is at the edge of our scene, reverse it's direction
		if ((targets[i].x < -g_border) || (targets[i].x > g_border)) {
			targets[i].dx *= -1;
		}
		if ((targets[i].y < 5) || (targets[i].y > 50)) {
			targets[i].dy *= -1;
		}
		if ((targets[i].z < -g_border) || (targets[i].z > g_border)) {
			targets[i].dz *= -1;
		}

		// decrement the cycle counter (sphere vs. particle)
		targets[i].counter -= 1;

		// check for when the current cycle is ended
		if (targets[i].counter == 0) {

			// if the "sphere" cycle just ended
			if (targets[i].cycle == 1) {

				// hide the target sphere
				dbHideObject(targets[i].obj);

				// tell the particle system to start emitting 10 particles per frame(?)
				dbSetParticleEmissions(targets[i].obj, 10);

				// set the cycle to last for 20 cycles
				targets[i].counter = g_particleLife;
			}
			else {	// otherwise the "particle" cycle has ended

				// show the target sphere
				dbShowObject(targets[i].obj);

				// reposition the target at a random location
				targets[i].x = dbRnd(g_size) - (g_border);
				targets[i].y = dbRnd(10) + 10;
				targets[i].z = dbRnd(g_size) - (g_border);

				// tell the particle system to stop emitting
				dbSetParticleEmissions(targets[i].obj, 0);

				// set the cycle to last for a random number of cycles up to g_maxLife
				targets[i].counter = dbRnd(g_maxLife);
			}

			// toggle between cycles (1 and -1)
			targets[i].cycle *= -1;
		}

		// position the target elements
		dbPositionObject(targets[i].obj, targets[i].x, targets[i].y, targets[i].z);
		dbPositionParticleEmissions(targets[i].obj, targets[i].x, targets[i].y, targets[i].z);
	}
}

/******************************************************************************
* Update the lights every cycle
******************************************************************************/
void updateLights(void) {
	float x, y, z, color;

	g_sunAngle = dbWrapValue(g_sunAngle + g_dAngle);
	dbXRotateObject(g_sun, g_sunAngle);
	dbXRotateObject(g_moon, dbWrapValue(g_sunAngle + 180));

	x = dbLimbPositionX(g_sun, 1);
	y = dbLimbPositionY(g_sun, 1);
	z = dbLimbPositionZ(g_sun, 1);

	dbPositionLight(0, x, y, z);

	x = dbLimbPositionX(g_moon, 1);
	y = dbLimbPositionY(g_moon, 1);
	z = dbLimbPositionZ(g_moon, 1);

	dbPositionLight(1, x, y, z);

	x = dbCameraPositionX();
	z = dbCameraPositionZ();

	dbPositionLight(2, x, 10, z);

	if ((g_sunAngle > 0) && (g_sunAngle <= 180)) {
		g_skyColor -= g_dColor;
	} else {
		g_skyColor += g_dColor;
	}
	dbColorBackdrop(dbRGB(255*g_skyColor, 255*g_skyColor*1.25, 255*g_skyColor*2));
}

/******************************************************************************
* 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;

	// locking the pixes speeds up most image functions
	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);
		}
	}

	// unlock the pixels so we can get back to work
	dbUnlockPixels();
}

#include "DarkGDK.h"

/******************************************************************************
* Constants
******************************************************************************/
// textures
const int g_texParticle = 1;
const int g_texMatrix   = 2;
//**/ this was added for the camera demo
/**/ const int g_texScreen   = 3;

// matrix information
const int g_objMatrix = 1;
const int g_size = 400;
const int g_border = g_size / 2;

// number of targets
const int g_numTargets = 50;

// available target numbers to use for the g_sun and g_moon objects
const int g_sun  = g_numTargets + 1;
const int g_moon = g_numTargets + 2;

// universal target info
const int g_maxLife = 1000;
const int g_particleLife = 20;

// target object
struct sTarget {
	int obj, cycle, counter;
	float x, y, z, dx, dy, dz;
};

struct sTarget targets[g_numTargets];

// stuff for our "celestial bodies" and the light they emit
float g_sunAngle = 0;
float g_skyColor = 0.18;
float g_dAngle = 0.1;
float g_dColor = g_dAngle / 1000.0;

/******************************************************************************
* Function prototypes
******************************************************************************/
void init(void);
void makeTextures(void);
void makeWorld(void);
void makeTargets(void);
void makeLights(void);
void update(void);
void updateTargets(void);
void updateLights(void);
void semiRandomTile(int left, int top, int width, int height, int rMax, int gMax, int bMax);
//**/ this was added for the camera demo
/**/ void makeCameras(void);

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

	init();

	// our main loop
	while (LoopGDK()) {
		dbControlCameraUsingArrowKeys(1, 1.0, 5.0);
		// update the screen
		update();
		dbSync();
	}

	// return back to windows
	return;
}

/******************************************************************************
* Perform all of our initialization stuff
******************************************************************************/
void init(void) {
	// turn on sync rate and set maximum rate to 60 fps
	dbSyncOn();
	dbSyncRate(60);

	// initialize the back buffer
	dbSync();

	// hide the mouse and turn off the autocam feature
	dbHideMouse();
	dbAutoCamOff();

	// make the application fullscreen (method 1 -- this should usually work)
	dbSetWindowOff();
	// make the application fullscreen (method 2 -- use this when you have problems with method 1)
//	dbSetWindowLayout(0, 0, 0);
//	dbMaximizeWindow();

	// initialize the relevant parts of the scene
	makeTextures();
	makeWorld();
	makeTargets();
	makeLights();

	//**/ this was added for the camera demo
	makeCameras();
}

/******************************************************************************
* Make all of our textures
******************************************************************************/
void makeTextures(void) {
	//**/ this was modified for the camera demo
	// create a temporary workspace bitmap
	dbCreateBitmap(1, 640, 480);
		// get our particle texture
		dbInk(dbRGB(255, 255, 255), 0);
		dbBox(2, 2, 3, 3);
		dbGetImage(g_texParticle, 0, 0, 6, 6);

		// get our matrix texture
		semiRandomTile(0, 0, 256, 256, 32, 128, 64);
		dbGetImage(g_texMatrix, 0, 0, 256, 256);

	//**/ this was added for the camera demo
	dbGetImage(g_texScreen, 0, 0, 640, 480);

	// toggle all drawing operations back to the screen (bitmap #0)
	dbSetCurrentBitmap(0);
	// delete our workspace
	dbDeleteBitmap(1);
}

/******************************************************************************
* Build our scene
******************************************************************************/
void makeWorld(void) {
	// make floor using a matrix -- I haven't figured out how to properly light a large plane
	dbMakeMatrix(g_objMatrix, g_size, g_size, 50, 50);
	dbPrepareMatrixTexture(g_objMatrix, g_texMatrix, 1, 1);
	dbSetMatrix(g_objMatrix, 0, 0, 1, 1, 1, 1, 1);
	dbPositionMatrix(g_objMatrix, -(g_size / 2), 0, -(g_size / 2));
	dbUpdateMatrix(g_objMatrix);
}

/******************************************************************************
* Make all of our target spheres and their related particle systems
******************************************************************************/
void makeTargets(void) {
	int i, r, g, b;

	for (i = 0; i < g_numTargets; i++) {
		// set the target's color
		r = (dbRnd(3) + 1) * 63;
		g = (dbRnd(3) + 1) * 63;
		b = (dbRnd(3) + 1) * 63;

		// set the targets object number
		targets[i].obj = i+1;

		// set the cycle to the "sphere" cycle
		targets[i].cycle = 1;

		// set the target's lifetime for this cycle
		targets[i].counter = dbRnd(g_maxLife);

		// set the target's starting position
		targets[i].x = dbRnd(g_size) - (g_border);
		targets[i].y = dbRnd(10) + 10;
		targets[i].z = dbRnd(g_size) - (g_border);

		// set the targets direction, disallowing values of 0
		targets[i].dx = dbRnd(1);
		if (targets[i].dx == 0) { targets[i].dx = -1; }

		targets[i].dy = (dbRnd(1)) / 10.0;
		if (targets[i].dy == 0) { targets[i].dy = -0.1; }

		targets[i].dz = dbRnd(1);
		if (targets[i].dz == 0) { targets[i].dz = -1; }

		// make the target sphere -- our visual cue as to where the targets are
		dbMakeObjectSphere(targets[i].obj, 10.0);
		dbPositionObject(targets[i].obj, targets[i].x, targets[i].y, targets[i].z);
		dbColorObject(targets[i].obj, dbRGB(r, g, b));

		// initialize the particle system for the target -- notice emissions is set to 0 for now
		dbMakeParticles(targets[i].obj, 1, 10, 10);
		dbSetParticleEmissions(targets[i].obj, 0);
		dbSetParticleSpeed(targets[i].obj, 0.01);
		dbSetParticleGravity(targets[i].obj, 2.0);
		dbColorParticles(targets[i].obj, r, g, b);
		dbPositionParticleEmissions(targets[i].obj, targets[i].x, targets[i].y, targets[i].z);
	}
}

/******************************************************************************
* Initialize all of the lights for our scene
******************************************************************************/
void makeLights(void) {
	int g_sunColor  = dbRGB(255, 255, 192);
	int g_moonColor = dbRGB(64, 64, 72);

	// setting this to 0 lets us see the effects of our lights
	dbSetAmbientLight(0);

	// make the sun light (range chosen after a bit of tinkering)
	dbSetPointLight(0, 0, g_size, 0);
	dbColorLight(0, g_sunColor);
	dbSetLightRange(0, g_size * 1000);

	// make a sphere object for our sun
	dbMakeObjectSphere(g_sun, 200);

	// snag a copy of the mesh to use as the actual sun
	dbMakeMeshFromObject(1, g_sun);

	// add the mesh as a new limb and position it at "high noon"
	dbAddLimb(g_sun, 1, 1);
	dbOffsetLimb(g_sun, 1, 0, g_size*2, 0);

	// delete the mesh
	dbDeleteMesh(1);

	// hide the base limb -- I don't know if there's a better way, but this worked
	dbHideLimb(g_sun, 0);

	// make the sun glow
	dbSetObjectEmissive(g_sun, g_sunColor);
//	dbGhostObjectOn(g_sun);

	// make our moon light
	dbMakeLight(1);
	dbSetPointLight(1, 0, g_size, 0);
	dbColorLight(1, g_moonColor);
	dbSetLightRange(1, g_size * 2);

	// make the moon object
	dbMakeObjectSphere(g_moon, 100);

	// snag a copy of the mesh to use as the actual moon
	dbMakeMeshFromObject(1, g_moon);

	// add the mesh from before as a new limb and position it at "high noon"
	dbAddLimb(g_moon, 1, 1);
	dbOffsetLimb(g_moon, 1, 0, g_size*2, 0);

	// hide the base limb -- I don't know if there's a better way, but this worked
	dbHideLimb(g_moon, 0);

	// delete the mesh
	dbDeleteMesh(1);

	// make the moon glow
	dbSetObjectEmissive(g_moon, g_moonColor);
	dbGhostObjectOn(g_moon);

	// make the player light (follows the camera)
	dbMakeLight(2);
	dbSetPointLight(2, 0, 10, 0);
	dbColorLight(2, dbRGB(0, 64, 255));
	dbSetLightRange(2, 40);
}

/******************************************************************************
* Calls the other update functions -- I just wrote this to clean up the
* game loop a bit -- for speed purposes, I would remove it in the future.
******************************************************************************/
void update(void) {
	updateTargets();
	updateLights();
}

/******************************************************************************
* Update the targets every cycle
******************************************************************************/
void updateTargets(void) {
	int i;
	float x, z, angle;

	// update each one of the targets
	for (i = 0; i < g_numTargets; i++) {

		// modify the target's position based on the direction modifiers
		targets[i].x += targets[i].dx;
		targets[i].y += targets[i].dy;
		targets[i].z += targets[i].dz;

		// if the target is at the edge of our scene, reverse it's direction
		if ((targets[i].x < -g_border) || (targets[i].x > g_border)) {
			targets[i].dx *= -1;
		}
		if ((targets[i].y < 5) || (targets[i].y > 50)) {
			targets[i].dy *= -1;
		}
		if ((targets[i].z < -g_border) || (targets[i].z > g_border)) {
			targets[i].dz *= -1;
		}

		// decrement the cycle counter (sphere vs. particle)
		targets[i].counter -= 1;

		// check for when the current cycle is ended
		if (targets[i].counter == 0) {

			// if the "sphere" cycle just ended
			if (targets[i].cycle == 1) {

				// hide the target sphere
				dbHideObject(targets[i].obj);

				// tell the particle system to start emitting 10 particles per frame(?)
				dbSetParticleEmissions(targets[i].obj, 10);

				// set the cycle to last for 20 cycles
				targets[i].counter = g_particleLife;
			}
			else {	// otherwise the "particle" cycle has ended

				// show the target sphere
				dbShowObject(targets[i].obj);

				// reposition the target at a random location
				targets[i].x = dbRnd(g_size) - (g_border);
				targets[i].y = dbRnd(10) + 10;
				targets[i].z = dbRnd(g_size) - (g_border);

				// tell the particle system to stop emitting
				dbSetParticleEmissions(targets[i].obj, 0);

				// set the cycle to last for a random number of cycles up to g_maxLife
				targets[i].counter = dbRnd(g_maxLife);
			}

			// toggle between cycles (1 and -1)
			targets[i].cycle *= -1;
		}

		// position the target elements
		dbPositionObject(targets[i].obj, targets[i].x, targets[i].y, targets[i].z);
		dbPositionParticleEmissions(targets[i].obj, targets[i].x, targets[i].y, targets[i].z);
	}
}

/******************************************************************************
* Update the lights every cycle
******************************************************************************/
void updateLights(void) {
	float x, y, z, color;

	g_sunAngle = dbWrapValue(g_sunAngle + g_dAngle);
	dbXRotateObject(g_sun, g_sunAngle);
	dbXRotateObject(g_moon, dbWrapValue(g_sunAngle + 180));

	x = dbLimbPositionX(g_sun, 1);
	y = dbLimbPositionY(g_sun, 1);
	z = dbLimbPositionZ(g_sun, 1);

	dbPositionLight(0, x, y, z);

	x = dbLimbPositionX(g_moon, 1);
	y = dbLimbPositionY(g_moon, 1);
	z = dbLimbPositionZ(g_moon, 1);

	dbPositionLight(1, x, y, z);

	// get the "live" camera's position
	x = dbCameraPositionX(1);
	z = dbCameraPositionZ(1);

	dbPositionLight(2, x, 10, z);

	if ((g_sunAngle > 0) && (g_sunAngle <= 180)) {
		g_skyColor -= g_dColor;
	} else {
		g_skyColor += g_dColor;
	}
	dbColorBackdrop(1, dbRGB(255*g_skyColor, 255*g_skyColor*1.25, 255*g_skyColor*2));
}

/******************************************************************************
* 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;

	// locking the pixes speeds up most image functions
	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);
		}
	}

	// unlock the pixels so we can get back to work
	dbUnlockPixels();
}

void makeCameras(void){
	int i, j;

	// this is our "live" camera that responds to user input
	dbMakeCamera(1);
	dbPositionCamera(1, 0, 5, 0);

	// render the "live" camera to a texture for our sprites
	dbSetCameraToImage(1, g_texScreen, 640, 480);

	// turn the backdrop on because otherwise the camera won't work right
	dbBackdropOn(1);
	dbColorBackdrop(1, 0);

	// position our "view" camera under the scene (tucked away where we can't see it)
	// I don't think this really matters considering that we're locking sprites to
	// the camera, thus blocking this camera's view of the scene
	dbPositionCamera(0, 0, -10, 0);

	// make the uncolored sprite (upper left)
	dbSprite(1, 0, 0, g_texScreen);
	dbSizeSprite(1, 320, 240);
	dbSetSpriteTextureCoord(1, 0, 0, 0);
	dbSetSpriteTextureCoord(1, 1, 0.5, 0);
	dbSetSpriteTextureCoord(1, 2, 0, 0.5);
	dbSetSpriteTextureCoord(1, 3, 0.5, 0.5);

	// make the red sprite (upper right)
	dbSprite(2, 320, 0, g_texScreen);
	dbSizeSprite(2, 320, 240);
	dbSetSpriteTextureCoord(2, 0, 0.5, 0);
	dbSetSpriteTextureCoord(2, 1, 1, 0);
	dbSetSpriteTextureCoord(2, 2, 0.5, 0.5);
	dbSetSpriteTextureCoord(2, 3, 1, 0.5);
	dbSetSpriteDiffuse(2, 255, 0, 0);

	// make the green sprite (lower left)
	dbSprite(3, 0, 240, g_texScreen);
	dbSizeSprite(3, 320, 240);
	dbSetSpriteTextureCoord(3, 0, 0, 0.5);
	dbSetSpriteTextureCoord(3, 1, 0.5, 0.5);
	dbSetSpriteTextureCoord(3, 2, 0, 1);
	dbSetSpriteTextureCoord(3, 3, 0.5, 1);
	dbSetSpriteDiffuse(3, 0, 255, 0);

	// make the blue sprite (lower right)
	dbSprite(4, 320, 240, g_texScreen);
	dbSizeSprite(4, 320, 240);
	dbSetSpriteTextureCoord(4, 0, 0.5, 0.5);
	dbSetSpriteTextureCoord(4, 1, 1, 0.5);
	dbSetSpriteTextureCoord(4, 2, 0.5, 1);
	dbSetSpriteTextureCoord(4, 3, 1, 1);
	dbSetSpriteDiffuse(4, 0, 0, 255);
}

// Dark GDK - The Game Creators - www.thegamecreators.com

// the wizard has created a very simple project that uses Dark GDK
// it contains the basic code for a GDK application

// whenever using Dark GDK you must ensure you include the header file
#include "DarkGDK.h"

// 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 );
	dbAutoCamOff();
	dbSetWindowOff();
	dbHideMouse();
	
	//make and position cones
	dbMakeObjectCone(1, 30);
	dbPositionObject(1, 15, 0, 0);
	dbColorObject(1, dbRGB(255,0, 0));
	dbMakeObjectCone(2, 30);
	dbPositionObject(2, 105, 0, 0);
    dbColorObject(2, dbRGB(0, 0, 255));
	
	//make and position cameras
	dbMakeCamera(1);
	dbMakeCamera(2);
	dbPositionCamera(1, 15, 0, 0);
    dbPointCamera(1, 105, 0, 0);
	dbColorBackdrop(1, dbRGB(255,140, 0));
	dbColorBackdrop(2, dbRGB(100,100,100));
	dbPositionCamera(2, 105, 0, 0);
	dbPointCamera(2, 15, 0, 0);
    dbSetCurrentCamera(0);
	dbPositionCamera(0, 50, 0, -300);
	dbPointCamera(0, 50, 0, 0);
	dbSetCameraView(1, 0, 0, 110, 110);
	dbSetCameraView(2, 530, 0, 640 , 110);

	dbMakeObjectPlain(3, 30, 30);
	dbPositionObject(3, 0, 0, 0);
	dbRotateObject(3, 0, 90, 0);

	dbMakeObjectPlain(4, 30, 30);
	dbPositionObject(4, 135, 0, 0);
	dbRotateObject(4, 0, 90, 0);

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

	// return back to windows
	return;
}

// Dark GDK - The Game Creators - www.thegamecreators.com

// the wizard has created a very simple 3D project that uses Dark GDK
// it can be used as a starting point in making your own 3D games

// whenever using Dark GDK you must ensure you include the header file
#include "DarkGDK.h"

void collision();
// the main entry point for the application is this function
void DarkGDK ( void )
{
	// in this application we are going to create some 3D objects
	// and position them on screen

	// when starting a Dark GDK program it is useful to set global
	// application properties, we begin by turning the sync rate on,
	// this means we control when the screen is updated, we also set
	// the maximum rate to 60 which means the maximum frame rate will
	// be set at 60 frames per second
	dbSyncOn   ( );
	dbSyncRate ( 60 );
	int level = 1;
	dbAutoCamOff();
	//Set the Board up	
	dbXRotateObject ( 2 , dbRnd (360));
	dbYRotateObject ( 2 , dbRnd (360));
	dbZRotateObject ( 2 , dbRnd (360));
	dbMakeObjectBox ( 1 , 100 , 100 , -100 );
	dbPositionObject ( 1 , 0 , 0 , 0);
	dbGhostObjectOn (1);
	dbMakeObjectSphere (2 , 5);
	dbPositionObject ( 2 , 0 , 0 , 0);
	dbSetGlobalCollisionOn ();

	// move our camera back so we can view the objects
	dbMakeCamera ( 1 );
	dbPositionCamera (  1 , 0, 0, -150 );
	dbPointCamera ( 1 ,0 , 0 , 0 );

	// now we come to our main loop, we call LoopGDK so some internal
	// work can be carried out by the GDK
	while ( LoopGDK ( ) )
	{
		dbMoveObject ( 2 , 1 );
		if (dbObjectCollision ( 1 , 2 ) == 1)
		{
			collision();
		}

		
		
		// here we make a call to update the contents of the screen
		dbSync ( );
	}

	

	// and now everything is ready to return back to Windows
	return;
}
void collision()
{
	dbXRotateObject ( 2 , dbRnd (360));
	dbYRotateObject ( 2 , dbRnd (360));
	dbZRotateObject ( 2 , dbRnd (360));
}

float x = 20.0;
float y = 10.0;
float z = 20.0;
float angle = 0.0;

// initialize the camera
dbAutoCamOff();
dbPositionCamera(x, y, z);
dbPointCamera(0.0, 0.0, 0.0);

// This distance is 30 even.  You could just set it that way but
// I wanted to make sure you knew how I came up with that number.
float distance = sqrt(x*x + y*y + z*z);

while(LoopGDK()) {
   // move the camera forward to the origin
   dbMoveCamera(distance);

   // rotate the camera around the Y axis
   dbYRotateCamera(angle);

   // move the camera back away from the origin
   dbMoveCamera(-distance);

   // update our angle of rotation
   angle = dbWrapValue(angle + 1.0);
}

#include "DarkGDK.h"

/******************************************************************************
* Change these constants in pairs to affect the level of detail.
* g_level - Determines how deeply we travel using the recursive addShape()
*			function.
* g_limbs - Used to declare an array for our limb adjustment info.  You could
*			set it to the maximum, but why waste memory?
******************************************************************************/
/**
const int g_level = 0;
const int g_limbs = 1;
/**
const int g_level = 1;
const int g_limbs = 7;
/**
const int g_level = 2;
const int g_limbs = 37;
/**
const int g_level = 3;
const int g_limbs = 187;
/**/
const int g_level = 4;
const int g_limbs = 937;
/**
const int g_level = 5;
const int g_limbs = 4687;
/**
const int g_level = 6;
const int g_limbs = 23437;
/**/
/*****************************************************************************/

// the current limb available for use in our object
int g_currentLimb = 1;

/******************************************************************************
* Define our limb data structure and our limb array based on the constant
* g_limbs set above.
******************************************************************************/
struct sLimb {
	float x, y, z;
	float dx, dy, dz;
};

struct sLimb limbs[g_limbs];

/******************************************************************************
* function prototypes
******************************************************************************/
void makeComplexShape();
void addShapes(int level, float size, float px, float py, float pz, int x, int y, int z);
void handleAnimation(int counter);

/******************************************************************************
* the main entry point for the application is this function
******************************************************************************/
void DarkGDK(void) {
	float angle = 0.0;
	int counter = 0;
	int delta = 1;

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

	// switch to fullscreen mode
	dbSetWindowOff();

	// make our shape
	makeComplexShape();

	// position the camera where we can see the shape
	dbPositionCamera(0, 0, -10);

	// our main loop
	while (LoopGDK()) {
		// rotate the object by 0.1 degrees per frame
		dbYRotateObject(1, angle);
		angle = dbWrapValue(angle + 0.1);

		// expand or contract based on the counter
		handleAnimation(counter);

		// adjusts the counter up or down based on delta
		counter += delta;

		// since angle is changing by 0.1 degrees each frame, this cycles
		// our inverts delta roughly every 45 degrees
		if ((counter < 0) || (counter > 450)) {
			delta *= -1;
		}

		// update the screen
		dbSync();
	}

	// return back to windows
	return;
}

/******************************************************************************
* Make our center shape, the mesh we'll use throughout and call our level 1
* shape-functions if necessary
******************************************************************************/
void makeComplexShape() {
	//dbMakeObjectSphere(1, 1.0);
	dbMakeObjectCube(1, 1.0);
	dbMakeMeshFromObject(1, 1);

	if (g_level > 0) {
	   // make cubes to the left and right
	   addShapes(g_level, 1.0, 0, 0, 0,  1,  0,  0);
	   addShapes(g_level, 1.0, 0, 0, 0, -1,  0,  0);

	   // make cubes to the top and bottom
	   addShapes(g_level, 1.0, 0, 0, 0,  0,  1,  0);
	   addShapes(g_level, 1.0, 0, 0, 0,  0, -1,  0);

	   // make cubes to the front and back
	   addShapes(g_level, 1.0, 0, 0, 0,  0,  0,  1);
	   addShapes(g_level, 1.0, 0, 0, 0,  0,  0, -1);
	}
}

/******************************************************************************
* The recursive function that makes all of our little shapes
******************************************************************************/
void addShapes(int level, float size, float px, float py, float pz, int x, int y, int z) {
	// set up our new size and scale
	float newSize = size / 2.0;
	float scale = 100 * newSize;

	// set the current shape's position based on it's parents position and the direction we moved
	px += (x * size) * 1.2;
	py += (y * size) * 1.2;
	pz += (z * size) * 1.2;

	// add the limb, positioning and scaling it properly
	dbAddLimb(1, g_currentLimb, 1);
	dbOffsetLimb(1, g_currentLimb, px, py, pz);
	dbScaleLimb(1, g_currentLimb, scale, scale, scale);

	// set up our animation data
	limbs[g_currentLimb].x = px;
	limbs[g_currentLimb].y = py;
	limbs[g_currentLimb].z = pz;
	limbs[g_currentLimb].dx = x * 0.01;
	limbs[g_currentLimb].dy = y * 0.01;
	limbs[g_currentLimb].dz = z * 0.01;

	// move on the the next available limb
	g_currentLimb += 1;

	// if we're not at the bottom level go down again
	if (level > 1) {
		level -= 1;

		// add new shapes only in empty space
		if (x == 0) {
			addShapes(level, newSize, px, py, pz,  1, 0, 0);
			addShapes(level, newSize, px, py, pz, -1, 0, 0);
		} else { // if x != 0 then only make 1 shape that doesn't intersect an existing shape
			addShapes(level, newSize, px, py, pz, x, 0, 0);
		}
		if (y == 0) {
			addShapes(level, newSize, px, py, pz, 0,  1, 0);
			addShapes(level, newSize, px, py, pz, 0, -1, 0);
		} else { // if y != 0 then only make 1 shape that doesn't intersect an existing shape
			addShapes(level, newSize, px, py, pz, 0, y, 0);
		}
		if (z == 0) {
			addShapes(level, newSize, px, py, pz, 0, 0,  1);
			addShapes(level, newSize, px, py, pz, 0, 0, -1);
		} else { // if z != 0 then only make 1 shape that doesn't intersect an existing shape
			addShapes(level, newSize, px, py, pz, 0, 0, z);
		}
	}
}

/******************************************************************************
* Update the shape's positions based on the counter and their "deltas" (d[xyz])
******************************************************************************/
void handleAnimation(int counter) {
	float x, y, z;

	// step through every limb except limb 0 (the root limb) and update it
	for (int i = 1; i < g_limbs; i++) {
		x = limbs[i].x + (counter * limbs[i].dx);
		y = limbs[i].y + (counter * limbs[i].dy);
		z = limbs[i].z + (counter * limbs[i].dz);

		dbOffsetLimb(1, i, x, y, z);
	}
}

// Dark GDK - The Game Creators - www.thegamecreators.com

// the wizard has created a very simple project that uses Dark GDK
// it contains the basic code for a GDK application

// whenever using Dark GDK you must ensure you include the header file
#include "DarkGDK.h"

// the main entry point for the application is this function

//globals
int Xval = 0;
int intervalX = 0;
int intervalY = 0;

//prototypes
void SpinConeXY(int Cone, int Xval, int Yval);
void MakeObjects ();
void MakeCameras ();

void DarkGDK ( void )
{
	// turn on sync rate and set maximum rate to 60 fps
	dbSyncOn   ( );
	dbSyncRate ( 60 );
	dbAutoCamOff();
	dbSetWindowOff();
	dbHideMouse();
	
	MakeObjects();
	MakeCameras();

	// our main loop
	while ( LoopGDK ( ) )
	{
		// update the screen
		dbSync ( );
		//if (interval <= 360) {
			intervalX = dbWrapValue(intervalX + 15);
			intervalY = dbWrapValue(intervalY + 15);
			SpinConeXY(1, intervalX, intervalY);
			SpinConeXY(2, intervalX, intervalY);
		//}
		
	}

	// return back to windows
	return;
}

void SpinConeXY (int Cone, int Xval, int Yval) {
		
		dbRotateObject(Cone, Xval, 0, 0);
		//insert code to rotate cone around plain
		
}

void MakeObjects () {
	//make and position objects
	dbMakeObjectCone(1, 30);
	dbPositionObject(1, 15, 0, 0);
	dbPointObject(1, 0, 0, 0);
	dbColorObject(1, dbRGB(255,0, 0));

	dbMakeObjectCone(2, 30);
	dbPositionObject(2, 105, 0, 0);
	dbPointObject(2, 135, 0, 0);
    dbColorObject(2, dbRGB(0, 0, 255));

	dbMakeObjectPlain(3, 30, 30);
	dbPositionObject(3, 0, 0, 0);
	dbRotateObject(3, 0, 90, 0);

	dbMakeObjectPlain(4, 30, 30);
	dbPositionObject(4, 135, 0, 0);
	dbRotateObject(4, 0, 90, 0);
}

void MakeCameras () {
	//make and position cameras
	dbMakeCamera(1);
	dbMakeCamera(2);
	dbPositionCamera(1, 15, 0, 0);
    dbPointCamera(1, 105, 0, 0);
	//dbColorBackdrop(1, dbRGB(255,140, 0));
	//dbColorBackdrop(2, dbRGB(100,100,100));
	dbPositionCamera(2, 105, 0, 0);
	dbPointCamera(2, 15, 0, 0);
    dbSetCurrentCamera(0);
	dbPositionCamera(0, 50, 0, -300);
	dbPointCamera(0, 50, 0, 0);
	dbSetCameraView(1, 0, 0, 110, 110);
	dbSetCameraView(2, 530, 0, 640 , 110);

}

#include "DarkGDK.h"

/******************************************************************************
* The simplest way I've found to successfully include the string library is to
* go to the menu under:
*
*	Project -> [Your project name] Settings (or just hit Alt+F7)
*
* From there, click on:
*
*	Configuration Properties -> C/C++ -> Code Generation
*
* and change the Runtime Library option from Multi-threaded Debug(/MTd) to
* Multi-threaded(/MT).  Tempicek explained it very clearly on the forum that
* the DGDK doesn't have any Debug libraries (It still took me 30 minutes for
* that to sink in -- I know, I'm slow).  Apparently, to prevent Linker errors,
* you must tell the Linker not to include any of the other Debug libraries
* either.  You can still debug your own code, you just can't do any "deep"
* debugging into the MS or DGDK libraries.  That shouldn't be an issue for most
* of us.
*
* I won't claim this explanation is more than about 50% accurate, but if you
* want the real deal and actually wanna learn how the linker works, check
* out Tempicek's explanation at:
*
* http://forum.thegamecreators.com/?m=forum_view&t=121186&b=22&p=0
******************************************************************************/
#include <string>

// this is a helper function to make the main body of code more readable
inline void myPrint(std::string str) { dbPrint((char*)(str.c_str())); }

// function prototypes
void listPlayers(void);

/******************************************************************************
* the main entry point for the application is this function
******************************************************************************/
void DarkGDK(void) {
	// set up our 
	char* serverName = "Challenge Server";
	char* playerName = "Pharoseer";

	// set up our beginning message
	std::string msg("Attempting to connect to [");
	// add the server name to our message
	msg.append(serverName);
	// add the next little bit
	msg.append("] as [");
	// add the player name
	msg.append(playerName);
	// then add the finishing touches
	msg.append("].  Please wait...");

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

	// don't forget to initialize the backbuffer or we won't see the first
	// print statement
	dbSync();

	// Notice the call to the myPrint function -- NOT dbPrint.  Only being used
	// once like this doesn't make it worth writing a separate function, but if
	// you called it 50 or 100 times it'd be a lot easier to read and a lot
	// easier to debug.
	myPrint(msg);
	dbSync();

	// set up a default net game -- the simplest way to go
	dbDefaultNetGame("Challenge Server", "Pharoseer", 8, 1);

	// clear the screen (see the Core commands)
	// not to be confused with dbCls() in the Basic2D commands
	dbCLS();

	// list all of the connected players
	listPlayers();

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

	// return back to windows
	return;
}

void listPlayers(void) {
	int numPlayers;

	// get a list of all the connected players
	dbPerformChecklistForNetPlayers();
	numPlayers = dbChecklistQuantity();

	// if no players were found, report the issue
	if (numPlayers == 0) {
		dbPrint("No players found.");
	} else {
		// otherwise display their names
		dbPrint("Players connected to server:");
		dbPrint("---------------------------");
		for (int i = 1; i <= numPlayers; i++) {
			dbPrint(dbChecklistString(i));
		}
	}
}

#include "DarkGDK.h"

// function prototypes
void drawCircle(int iX, int iY, int iRadius);
void fillCircle(int iX, int iY, int iRadius);

void drawEllipse(int iX, int iY, int iXRadius, int iYRadius);
void fillEllipse(int iX, int iY, int iXRadius, int iYRadius);

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

	dbSetWindowOff();

	// our main loop
	while (LoopGDK()) {
		dbInk(dbRGB(dbRnd(255), dbRnd(255), dbRnd(255)), 0);
		if (dbSpaceKey() == 1) {
			drawEllipse(dbRnd(639), dbRnd(479), 16, 8);
		} else {
			drawEllipse(dbRnd(639), dbRnd(479), 8, 16);
		}
		drawCircle(dbRnd(639), dbRnd(479), 8);
		// update the screen
		dbSync();
	}

	// return back to windows
	return;
}

void drawCircle(int iX, int iY, int iRadius) {
	int f     = 1 - iRadius;
	int ddf_x = 0;
	int ddf_y = -2 * iRadius;
	int x     = 0;
	int y     = iRadius;

	dbLockPixels();

	dbDot(iX - iRadius, iY);
	dbDot(iX + iRadius, iY);
	dbDot(iX, iY + iRadius);
	dbDot(iX, iY - iRadius);

	while (x < y) {
		if (f >= 0) {
			y--;
			ddf_y += 2;
			f += ddf_y;
		}
		x++;
		ddf_x += 2;
		f += ddf_x + 1;

		dbDot(iX + x, iY + y);
		dbDot(iX - x, iY + y);
		dbDot(iX + x, iY - y);
		dbDot(iX - x, iY - y);

		dbDot(iX + y, iY + x);
		dbDot(iX - y, iY + x);
		dbDot(iX + y, iY - x);
		dbDot(iX - y, iY - x);
	}

	dbUnlockPixels();
}

void fillCircle(int iX, int iY, int iRadius) {
	int f     = 1 - iRadius;
	int ddf_x = 0;
	int ddf_y = -2 * iRadius;
	int x     = 0;
	int y     = iRadius;

	dbLockPixels();

	dbLine(iX, iY - iRadius, iX, iY + iRadius);
	dbLine(iX - iRadius, iY, iX + iRadius, iY);

	while (x < y) {
		if (f >= 0) {
			y--;
			ddf_y += 2;
			f += ddf_y;
		}
		x++;
		ddf_x += 2;
		f += ddf_x + 1;

		dbLine(iX - x, iY + y, iX + x, iY + y);
		dbLine(iX - x, iY - y, iX + x, iY - y);

		dbLine(iX - y, iY + x, iX + y, iY + x);
		dbLine(iX - y, iY - x, iX + y, iY - x);
	}

	dbUnlockPixels();
}

inline void drawEllipsePoints(int x, int y, int dx, int dy) {
	dbDot(x + dx, y + dy);
	dbDot(x - dx, y + dy);
	dbDot(x - dx, y - dy);
	dbDot(x + dx, y - dy);
}

void drawEllipse(int iX, int iY, int iXRadius, int iYRadius) {
	int x, y;
	int dx, dy;
	int error;
	int twoXSquare, twoYSquare;
	int stopX, stopY;

	twoXSquare = 2 * iXRadius * iXRadius;
	twoYSquare = 2 * iYRadius * iYRadius;

	x = iXRadius;
	y = 0;
	dx = iYRadius * iYRadius * (1 - 2 * iXRadius);
	dy = iXRadius * iXRadius;
	error = 0;
	stopX = twoYSquare * iXRadius;
	stopY = 0;

	while (stopX >= stopY) {
		drawEllipsePoints(iX, iY, x, y);
		y++;
		stopY += twoXSquare;
		error += dy;
		dy += twoXSquare;

		if ((2 * error + dx) > 0) {
			x--;
			stopX -= twoYSquare;
			error += dx;
			dx += twoYSquare;
		}
	}

	x = 0;
	y = iYRadius;
	dx = iYRadius * iYRadius;
	dy = iXRadius * iXRadius * (1 - 2 * iYRadius);
	error = 0;
	stopX = 0;
	stopY = twoXSquare * iYRadius;

	while (stopX <= stopY) {
		drawEllipsePoints(iX, iY, x, y);
		x++;
		stopX += twoYSquare;
		error += dx;
		dx += twoYSquare;

		if ((2 * error + dy) > 0) {
			y--;
			stopY -= twoXSquare;
			error += dy;
			dy += twoXSquare;
		}
	}
}

inline void drawEllipseLines(int x, int y, int dx, int dy) {
	dbLine(x - dx, y + dy, x + dx, y + dy);
	dbLine(x - dx, y - dy, x + dx, y - dy);
}

void fillEllipse(int iX, int iY, int iXRadius, int iYRadius) {
	int x, y;
	int dx, dy;
	int error;
	int twoXSquare, twoYSquare;
	int stopX, stopY;

	twoXSquare = 2 * iXRadius * iXRadius;
	twoYSquare = 2 * iYRadius * iYRadius;

	x = iXRadius;
	y = 0;
	dx = iYRadius * iYRadius * (1 - 2 * iXRadius);
	dy = iXRadius * iXRadius;
	error = 0;
	stopX = twoYSquare * iXRadius;
	stopY = 0;

	while (stopX >= stopY) {
		drawEllipseLines(iX, iY, x, y);
		y++;
		stopY += twoXSquare;
		error += dy;
		dy += twoXSquare;

		if ((2 * error + dx) > 0) {
			x--;
			stopX -= twoYSquare;
			error += dx;
			dx += twoYSquare;
		}
	}

	x = 0;
	y = iYRadius;
	dx = iYRadius * iYRadius;
	dy = iXRadius * iXRadius * (1 - 2 * iYRadius);
	error = 0;
	stopX = 0;
	stopY = twoXSquare * iYRadius;

	while (stopX <= stopY) {
		drawEllipseLines(iX, iY, x, y);
		x++;
		stopX += twoYSquare;
		error += dx;
		dx += twoYSquare;

		if ((2 * error + dy) > 0) {
			y--;
			stopY -= twoXSquare;
			error += dy;
			dy += twoXSquare;
		}
	}
}

#include "DarkGDK.h"

void makeTextures();

/******************************************************************************
* the main entry point for the application is this function
******************************************************************************/
void DarkGDK(void) {
	float x, y, z;

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

	// make some very simple textures
	makeTextures();

	// make a matrix to use as our "ground"
	dbMakeMatrix(1, 4000, 4000, 40, 40);
	dbPrepareMatrixTexture(1, 1, 1, 1);
	dbRandomizeMatrix(1, 100.0);
	dbUpdateMatrix(1);

	// make our skysphere (notice the negative radius -- that turns the sphere inside out)
	dbMakeObjectSphere(1, -1000);
	dbPositionObject(1, 0, 0, 0);
	dbTextureObject(1, 2);

	// scale the skysphere's texture so that the stars aren't big and chunky
	dbScaleObjectTexture(1, 8, 8);

	//position the camera
	dbPositionCamera(0, 5, 0);

	// our main loop
	while (LoopGDK()) {
		// update the screen
		dbControlCameraUsingArrowKeys(0, 1, 5);

		// get the camera's XZ (horizontal) positioning in the world
		x = dbCameraPositionX();
		z = dbCameraPositionZ();

		// use that position to adjust to our matrix "ground" height
		y = dbGetGroundHeight(1, x, z);

		// reposition the camera above the ground
		dbPositionCamera(x, y + 5, z);

		// reposition our skysphere so that we don't run into it
		dbPositionObject(1, x, 0, z);

		dbSync();
	}

	// return back to windows
	return;
}

void makeTextures() {
	int c, i, x, y;

	dbCreateBitmap(1, 256, 256);
		// makes a varied "grass" texture
		dbLockPixels();

		for (y = 0; y < 256; y++) {
			for (x = 0; x < 256; x++) {
				c = dbRGB(0, dbRnd(63) + 64, 0);
				dbInk(c, 0);
				dbDot(x, y);
			}
		}
		dbUnlockPixels();
		dbGetImage(1, 0, 0, 255, 255);

		// clear the bitmap to make our next texture
		dbCLS();

		// make a "starry sky" texture
		dbLockPixels();
		for (i = 0; i < 1000; i++) {
			c = dbRGB(dbRnd(127) + 128, dbRnd(127) + 128, dbRnd(127) + 128);
			dbInk(c, 0);
			x = dbRnd(255);
			y = dbRnd(255);
			dbDot(x, y);
		}
		dbUnlockPixels();
		dbGetImage(2, 0, 0, 255, 255);

	dbDeleteBitmap(1);
	dbSetCurrentBitmap(0);
}

///////////////////////////////Use arrow keys while program is running to rotate the matrix view///////////////////////////
#include "DarkGDK.h"


void DarkGDK ( void )
{
	
	dbSyncOn   ( );
	dbSyncRate ( 60 );
    //Cameras
	dbMakeCamera (0);
	dbMakeCamera (1);

	//Change these setting to generate maps
	float Seed = 7489239; //Random variable
	float Hills = 20; // Number of x, and z sections to the matrix
	float mHeight = 12.5; //Maximum height of map 
	float texture = 1; // 0 = Grey scale, 1= color
	char* filename = "tex2.jpg";//Change file name, use bmp for height maps, and jog for texture mode

	dbRandomize ( Seed );

	dbMakeMatrix (1, 256, 256, Hills, Hills);
	dbRandomizeMatrix (1, mHeight);
	dbPositionMatrix (1, 0, 10, 0);
	//Map maker
	dbSetCurrentBitmap(0);
	if (texture == 0)
	{
	 //height map
	 for ( int x = 1; x < 256; x++ )
		{
			for	 ( int y= 1; y < 256; y++ )
			{
				float pixx = dbGetGroundHeight (1, x, y);
				int pix = ( pixx *5 );
				dbInk ( dbRgb(pix, pix, pix), dbRgb (255,0,0) );
				dbDot ( x, y);
			}
		}
	}
	if (texture == 1)
	{
         int rTex = 0;
		 int gTex = 0;
		 int bTex = 0;
	 //Color Texture
	 for ( int x = 1; x < 256; x++ )
		{
			for	 ( int y= 1; y < 256; y++ )
			{
				float pixx = ( dbGetGroundHeight (1, x, y) + 10 );
				 int rTex = ( pixx *10 );
				 int gTex = ( pixx *10 );
				 int bTex = ( pixx *10 );
				dbInk ( dbRgb(rTex, gTex, bTex), dbRgb (255,0,0) );
				dbDot ( x, y);
			}
		}
	}
	dbSetCurrentBitmap(1);
	dbBlurBitmap (1, 6);
	dbCopyBitmap (1, 0);
	dbSetCurrentBitmap(0);	
	dbMakeMemblockFromBitmap (2, 0);
	dbMakeImageFromMemblock (3, 2);
	
	dbGetImage (3, 0, 0, 256, 256);
	dbSaveImage ( filename , 3);
	

	//set camera views
	dbSetCameraView (1, 0, 0, 256, 256);
	dbSetCameraToImage (1, 3, 256, 256);
	dbSetCameraView (0, 256, 0, 512, 256);
    dbPositionCamera (0, 0, 10, 0);
	

	while ( LoopGDK ( ) )
	{
		



		float fHeight= dbGetGroundHeight (1, dbCameraPositionX(0), dbCameraPositionZ(0));
		dbPositionCamera ( dbCameraPositionX(0), fHeight+40, dbCameraPositionZ(0) );

		if ( dbUpKey ( ) )
			dbMoveCamera (0, 4 );
		if ( dbDownKey ( ) )
			dbMoveCamera (0, -4 );
		if ( dbRightKey ( ) )
			dbTurnCameraRight  (0, 1 );
		if ( dbLeftKey ( ) )
			dbTurnCameraLeft  (0, 1 );
		
		
		
		// here we make a call to update the contents of the screen
		dbSync ( );
	}

	// before quitting delete our objects
	//for ( int i = 1; i < 50; i++ )
	//	dbDeleteObject ( i );

	// and now everything is ready to return back to Windows
	return;
}

//		Use The Mouse to Move the blue sphere, and the camera angle, Avoid the red blocks
//Left click = walk
//left click + Right click = run
//Midle click = pitch camera up/down
//Midle wheel (y) = zoom in/out
//
// A simple ai demo by Michael Carrozza
//
#include "DarkGDK.h"


void DarkGDK ( void )
{
	dbSyncOn   ( );
	dbSyncRate ( 60 );

	dbPrint ( "Please wait, loading..." );
	dbSync ( );
	dbSync ( );

	dbRandomize ( 629876435723 );

	dbSetCameraRange ( 1.0f, 240000.0f );
	
	//Terrain
	dbMakeMatrix (1, 10000, 10000, 20, 20);
	dbRandomizeMatrix (1, 50);
	dbPositionMatrix (1, 0, 0, 0);
	dbSetMatrix (1, 0, 1, 0, 1, 1, 1, 255);
	
	//bad guys
	dbMakeObjectCube ( 4, 40 );
	dbColorObject (4, dbRgb ( 255, 0, 0) );
	dbSetObjectNormals (4);
	dbSetObjectLight ( 4, 1 );
	dbPositionObject (4, 0, -1000, 0);
	for ( int i = 5; i < 50; i++ )
	{
		dbInstanceObject (i ,4);
		float mx = dbRnd ( 10000 );
		float mz = dbRnd ( 10000 );
		float iHeight = dbGetGroundHeight( 1 ,mx ,mz );
		dbPositionObject ( i, mx, iHeight+50, mz );
	}

	// Player Character
	dbMakeObjectSphere ( 3, 15 );
	dbColorObject (3, dbRgb ( 0, 0, 255) );
	dbSetObjectSmoothing ( 3, 180.0f );
	dbPositionObject (3, 900, 1000, 900);
	dbSetObjectLight ( 3, 1 );
	
	
	//Variables
	float fObjectAngle = 0.0f;
	float fCameraAngle = 0.0f;
	float fObjectAnglex = 0.0f;
	float fCameraZoom = 0.0f;
	float fCameraHeight = 70.0f;

	while ( LoopGDK ( ) )
	{
		float X = dbObjectPositionX(3);
		float Y = dbObjectPositionY(3);
		float Z = dbObjectPositionZ(3);
		float fHeight = dbGetGroundHeight( 1, dbObjectPositionX(3), dbObjectPositionZ(3) );
		fCameraAngle = dbWrapValue ( fCameraAngle + dbMouseMoveX ( ) * 0.4f );
		fCameraZoom = ( fCameraZoom + dbMouseMoveZ ( ) * 0.2f );
		

		if (fCameraZoom < 100) fCameraZoom = 100;
		if (fCameraZoom > 1000) fCameraZoom = 1000;

		if (dbMouseClick ( ) == 4) fCameraHeight =  ( fCameraHeight + dbMouseMoveY ( ) * 0.4f );

		dbPositionObject ( 3 ,dbObjectPositionX ( 3 ), fHeight+50, dbObjectPositionZ ( 3 ) );
		
		if ( dbMouseClick ( ) == 3) //RUN
		{
			dbYRotateObject ( 3, fCameraAngle);
			dbMoveObject ( 3, 4.2f );
		}
		if ( dbMouseClick ( ) == 1) //Walk
		{
			dbYRotateObject ( 3, fCameraAngle);
			dbMoveObject ( 3, 1.4f );
		}
		if ( dbSpaceKey ( ) == 2) //Attack
		{
			dbPlayObject ( 3, 155, 173 );
		}
		
		dbSetCameraToFollow ( dbObjectPositionX ( 3 ), dbObjectPositionY ( 3 ), dbObjectPositionZ ( 3 ), fCameraAngle, fCameraZoom, fCameraHeight, 10, 0);
		dbPointCamera ( dbObjectPositionX ( 3 ), dbObjectPositionY ( 3 )+50, dbObjectPositionZ ( 3 ) );
		
		/////////AI///////////////
		for ( int i = 5; i < 50; i++ )
		{
			float detectX = (dbObjectPositionX(i) - dbObjectPositionX (3));
			float detectY = (dbObjectPositionY(i) - dbObjectPositionY (3));
			float detectZ = (dbObjectPositionZ(i) - dbObjectPositionZ (3));


			float detected = dbSqrt( (detectX * detectX) + (detectY * detectY) + (detectZ * detectZ));
			//Keep the Monsters on the field
			if (dbObjectPositionX(i) >10000 )
			{
				dbPositionObject (i, 1, dbObjectPositionY (i), dbObjectPositionZ (i) );
			}
			if ( dbObjectPositionZ(i) >10000 )
			{
				dbPositionObject (i, dbObjectPositionX (i), dbObjectPositionY (i), 1 );
			}
			if (dbObjectPositionX(i) < 0 )
			{
				dbPositionObject (i, 9999, dbObjectPositionY (i), dbObjectPositionZ (i) );
			}
			if ( dbObjectPositionZ(i) < 0 )
			{
				dbPositionObject (i, dbObjectPositionX (i), dbObjectPositionY (i), 9999 );
			}

			//Ai
			if (detected <= 400)
			{
				dbPointObject (i, dbObjectPositionX (3), dbObjectPositionY (3), dbObjectPositionZ (3));
				dbMoveObject (i, 2);
			}
			else 
			{
				float monTurn = dbRnd (10);
				if (monTurn < 2)
				{
					dbTurnObjectLeft (i, 1);
				}
				if (monTurn >9)
				{
					dbTurnObjectRight (i, 1);
				}
				else
				{ 
					dbMoveObject (i, 0.5f);
				}
			}
		}
		

		// update
		dbSync ( );
	}

	// before quitting delete our objects
	for ( int i = 1; i < 500; i++ )
		dbDeleteObject ( i );
	for ( int i = 1; i < 500; i++ )
		dbDeleteMatrix ( i );

	// and now everything is ready to return back to Windows
	return;
}