I must be missing something because I have watched the videos time and time again and I still can't get my enemies to show up on my screen. The game runs and compiles without and issues whatsoever. Everything was going fine until I implemented the enemy class. Here is my code. If someone could take a look at it I would appreciate it. I've been working on trying to get it fixed for three days now and I'm burnt out, but it keeps bugging me. I'm using MSVS 2010 on Win7.

Code:
#ifndef enemy_h
#define enemy_h

#include "Sprite.h"

class Level;
class Character;

class enemy : public Sprite
{
public:
	enemy(Level *L, drawEngine *de, int s_index, float x = 1, float y = 1, int i_lives = 1);

	void addGoal(character *g);
	bool move(float x, float y);
	void idleUpdate(void);

protected:
	void simulateAI(void);
	character *goal;
};
#endif;



#include "enemy.h"
#include "Sprite.h"
#include "character.h"
#include "math.h"
#include "stdlib.h"




enemy::enemy(Level *L, drawEngine *de, int s_index, float x, float y, int i_lives)
	:Sprite(L, de, s_index, x, y, i_lives)
{
	goal = 0;
	classID = ENEMY_CLASSID;//enum in Sprite.h
}

bool enemy::move(float x, float y)
{
	int xpos = (int)(pos.x + x);
	int ypos = (int)(pos.y + y);

	if(isValidLevelMove(xpos, ypos))
	{
		//make sure we dont run into any other enemies
		erase(pos.x, pos.y);

		pos.x += x;
		pos.y += y;

		facingDirection.x = x;
		facingDirection.y = y;

		draw(pos.x, pos.y);

		return true;
	}
	return false;
}

void enemy::idleUpdate(void)
{
	if(goal)
	{
		simulateAI();
	}
}

void enemy::addGoal(character *g)
{
	goal = g;
}

void enemy::simulateAI(void)
{
	vector goal_pos = goal->getPosition();
	vector direction;

	direction.x = goal_pos.x - pos.x;
	direction.y = goal_pos.y - pos.y;

	float mag = sqrt((direction.x * direction.x) + (direction.y * direction.y));

	direction.x = direction.x / (mag * 5);
	direction.y = direction.y / (mag * 5);

	if(!move(direction.x, direction.y))
	{
		while(!move(rand() % 3 - 1, rand() % 3 - 1))
		{
			
		}
	}
}



#include "game.h"
#include <iostream>
#include <conio.h>
#include <Windows.h>
#include "level.h"
#include "time.h"

using namespace std;

#define GAME_SPEED 31.333

bool game::run(void)
{
	level = new Level(&drawArea, 30, 20);//allocate space for a new Level

	drawArea.createBGTile(TILE_EMPTY, 0);//defines the empty space
	drawArea.createBGTile(TILE_WALL, 219);//defines the walls

	drawArea.createSprite(SPRITE_ENEMY, '$');//create the enemy
	drawArea.createSprite(SPRITE_PLAYER, 1);//create the player


	player = new character(level, &drawArea, 0);

	level->draw();  //draw the Level
	level->addPlayer(player);
	level->addEnemies(1);

	char key = ' ';
	startTime = timeGetTime();
	frameCount = 0;
	lastTime = 0;
	posx = 0;
	player->move(0,0);
	while(key != 'q')
	{
		while(!getInput(&key))
		{
			timerUpdate();
			
		}

		level->keyPress(key);
	}

	delete player;

	return true;
}

bool game::getInput(char *c)
{
	if(kbhit())
	{
		*c = getch();
		return true;
	}
	return false;
}

void game::timerUpdate(void)
{
	double currentTime = timeGetTime() - lastTime;

	if(currentTime < GAME_SPEED)
		return;
	
	

	frameCount++;

	lastTime = timeGetTime();
}

#include "drawEngine.h"
#include <Windows.h>
#include <iostream>


using namespace std;

drawEngine::drawEngine(int xSize, int ySize)
{
	screenWidth = xSize;
	screenHeight = ySize;

	//set cursor visibiility to false
	cursorVisibility(false);

	map = 0;

}

drawEngine::~drawEngine()
{
	//set cursor visibility to true
	cursorVisibility(true);
}


int drawEngine::createSprite(int index, char c)
{

	if(index >= 0 && index < 16)
	{
		spriteImage[index] = c;
		return index;
	}
	return -1;
}

void drawEngine::deleteSprite(int index)
{
	// in this implementation we don't need this
}

void drawEngine::drawSprite(int index, int posx, int posy)
{
	gotoxy(posx, posy);
	cout << spriteImage[index];
}


void drawEngine::eraseSprite(int posx, int posy)
{
	gotoxy(posx, posy);
	cout << ' ';
}
void drawEngine::gotoxy(int x, int y)
{
	HANDLE output_handle;
	COORD pos;

	pos.X = x;
	pos.Y = y;

	output_handle = GetStdHandle(STD_OUTPUT_HANDLE);
	SetConsoleCursorPosition(output_handle, pos);
}

void drawEngine::cursorVisibility(bool visibility)
{
	HANDLE output_handle;
	CONSOLE_CURSOR_INFO cciInfo;

	cciInfo.dwSize = 1;
	cciInfo.bVisible = visibility;

	output_handle = GetStdHandle(STD_OUTPUT_HANDLE);

	SetConsoleCursorInfo(output_handle, &cciInfo);
}

void drawEngine::setMap(char ** data)
{
	map = data;
}

void drawEngine::createBGTile(int index, char c)
{
	if(index >= 0 && index < 16)
	{
		tileImage[index] = c;
	}
}
void drawEngine::drawBG(void)
{
	if(map)
	{
		for(int y = 0; y < screenHeight; y++)
		{
			gotoxy(0, y);

			for(int x = 0; x < screenWidth; x++)
			{
				cout << tileImage[map[x][y]];
			}
		}
	}
}