I have previously had some questions about classes and references/pointers on this forum. And - I got some good answers, mainly from major_small and Dae. Thanks to both of you!

Now, as it often is with answers, they mainly made me realize that there is a lot more I need to know.

My plan is to make an ASCII text game, featuring a Wild West theme, and a simple set of pen and paper RPG-style rules - WITH A TWIST!

I want to make it completely OOP. That means, I want to make easily reusable, adjustable, expandable, and portable code.
I want to make lots of little units (classes) of code that is able communicate and exchange information with eachother.
That is what I imagine real OOP is. Am I wrong?

I realize many programmers might think that it would be a waste of time, putting that much effort into a fairly simple ASCII game. But I don't care about that. For me, the object is not to make a game quickly, but to learn how to do C++ OOP, and have fun at the same time!

I have done some noob level programming in different languages from time to time, but C++ and espacially C++ classes and the OOP concept are very new to me. So what i'd really be grateful for, is any constructive criticism anyone can give me on style of code, consistency, variable/function/method naming, coment style, anything you can think of, on the following piece of code. I have comented on nearly everything, to try and demonstrate the limits of my knowledge.

Oh, and I relize that this is a HUGE post that represents A LOT of questions, but please bear with me, as i have never before had the opportunity to have a seasoned or, in fact, any programmer look at any of my code. And I really want to get this exactly right.

Code:
// Draw! -The name of the game.


#include <stdlib.h>          // This is where header files are included. I must admit
#include <iostream.h>        // that I don't know much about it, except they let me
#include <time.h>            // access certain functions, that would otherwise be
#include <conio.h>           // unavailable.
#include <string>


class human  // Class declaration. A class is just a definition that can be used
{            // to create an object.
	
	int health, gunSkill;			// These variables have the default
	string firstName, lastName, alias;      // protection level of Protected.
						// Protected variables and methods can
						// be accessed from anywhere inside the
						// object, but not from outside.
	
	public:	// Everything below this is public, meaning it can be accessed from
		// outside of the object to be.
	
	int dice[10];	// The program won't compile with this array protected. Why?
			// The constructor uses this variable, so is it because the
			// constructor creates the object, and is therefore not
			// really a part of it as such?
	
	human()	// This constructor lets me set default values for all the variables,
	{	// and call methods, whenever a new object is created.
		
		dice[0] = 0;
	}
	
	// I have decided not to include a destructor,
	// because I read on the C Board, that c++ provides
	// me with a default destructor.
	
	int rollDice(int numberOfDice, int sides)	// This is a method of the class.
	{						// It rolls up to 9 virtual dice
		int result=0;			        // with x number of sides, puts
							// the results in dice[], and
		if (numberOfDice>9)		        // returns the total.
		{					// The two if statements protects
			numberOfDice=9;			// the method from numberOfDice
		}					// being set too high, and devide
							// by zero errors (from sides
		if (sides>0)				// arguement being set to 0).
		{
			for (int x=0; x<numberOfDice; x++)
			{
				dice[x] = (rand()%sides)+1;
				result = result + dice[x];
			}
		}
			// This is my primitive way of returning an error message. That should probably
		else	// be handled by a sepparate class, but I don't know anything about that yet.
		{
			cout << endl << "Error! player.rollDice() arguement out of range.";
		}
		
		return result;
	}
	
        // I am not sure weather the following methods are desirable, or if I should
        // simply make those variables public.
	int getHealth()
	{		
		return health;
	}
	
	void setHealth(int newHealth)
	{
		health = newHealth;
	}
	
	int getGunSkill()
	{
		return gunSkill;
	}
	
	void setGunSkill(int newGunSkill)
	{
		gunSkill = newGunSkill;
	}
	
};

class player : public human	// Another class declaration. This one extends on previous class "human",
{			        // meaning it inherits all its variables and methods, except those that
			        // have private protection level.
	public:
	
	player()		// Now the constructor calls a method.
	{			// The code in the parent contructor is still carried out.
		gameStart();
	}
	
	~player()		// This time I have chosen to include a destructor, because I want to run a method
	{			// to inform the user, whenever a player object is destroyed.
		gameOver();
	}
	
	
	int rollDice(int numberOfDice, int sides)	// Since this method has the same name as one in its
	{						// parent class, this one will simply overwrite the
							// parent version.
		int result=0;
		cout << endl << "Please press a key to roll " << numberOfDice << "D" << sides << "!" << endl;
		
		getche();	// The getche() function checks the keyboard buffer, and returns its contents when
				// someting is pushed into it. Since I am not assigning that value to a variable,
				// it simply disappears into oblivion. However, I am not too happy with it, since
				// it seems to have the undesirable ability to produce wierd errors.
		
		if (numberOfDice>9)
		{
			numberOfDice=9;
		}
		
		if (sides>0)
		{
			for (int x=0; x<numberOfDice; x++)
			{
				dice[x] = (rand()%sides)+1;
				result = result + dice[x];
			}
		}
		
		else
		{
			cout << endl << "Error! player.rollDice() arguement out of range.";
		}
		
		dice[numberOfDice]=0;
		
		return result;
	}
	
	void sayDice()	// Gives a player object the ability to print its last die roll to the screen.
	{
		
		if (dice[0]!=0)
		{
			cout << endl << "Dice 1: " << dice[0];
			for (int x=1; dice[x]; x++)
			{
				cout << " Dice " << x+1 << ": " << dice[x];
			}
			cout << "." << endl;
		}
		else
		{
			cout << endl
			<< "Error! player.sayDice(): No dice were rolled." << endl
			<< "content of the array is:";
			
			for (int x=0; x<10; x++)
			{
				cout << endl << "Cell [" << x << "]: " << dice[x];
			}

		}
	}
	
	// The last two methods (that are called in the constructer and destructor) could contain
	// something like a character generation- and game over sequence. Or perhaps such things
	// should be kept in a separate "game" class, along with the rest of the game flow?
	void gameStart()
	{
		cout << endl << "There is a new sherrif in town";
	}
	
	void gameOver()
	{
		
		cout << endl << endl << "Game Over." << endl << "Press a key to exit";
		getche();
	}
};

int main()
{
	
	srand(time(0));        	// The srand() function is used together with the time() function to seed
				// the rand() function, so it will produce a different set of pseudo-random
				// numbers for each run. They are not really random, as they are picked from
				// a (very long) list, but "random" enough for the player not to recognize.
	
	player playerObject; // Here an object called "playerObject" is created from the player class.
	
	cout << endl
	<< "You now have the profound opportunity to roll 3 virtual 6 sided dice." << endl
	<< "Be careful in performing this dire task, as the result will determine your starting healt!";
	playerObject.setHealth(playerObject.rollDice(3, 6));
	playerObject.sayDice();
	
	cout << endl << "That makes your current health " << playerObject.getHealth() << ".";
	
	// I could destroy the object here, to free the memory
	// it exists in, like this:
	// ~playerObject();
	// However, I am not going to, since c++ does that
	// automatically when the main() function returns 0.
	
	
	return 0;
}
As you can see, there are some questions in there about how to structure my program. I imagine something like a "game" class to run everyting during the game, and a "system" class to handle system specific calls, to make it easier to port later. But I really could use a good wiev of what classes would generally be needed for a game, what they would do, and how they might interact.

I welcome answers from anyone, be it the noober- or the über-programmer!

Thank you in advance