Thread: Health...

Well it all depends on what you're using for graphics, OpenGL, basic GDI, etc. But either way I'd recommend storing it in a variable and then updating the screen so it will show the variable's new content after it's changed. Just a suggestion, don't get ahead of yourself.

You'll want to position the cursor one the screen, or (ugh) clear the whole screen and repaint the whole thing.

See the FAQ, or try gotoxy() in <conio.h>.

How's your object orientation concepts? The best thing to do
would be make yourself a very basic console app first - design
a fighter class and have methods for different attacks and
store health, then decrement the health for your oponent.
Here's some pseudo-code to point you in the right direction:

Code:

class Fighter
{
private:
	int health;
	string name;
	int kickstrength;
	int punchstrength;
        
public:
	//cxtrs here

	bool kickoponent (Fighter &oponent);
	bool punchoponent (Fighter &oponent);
	int GetHealth ();
	//and so on for more detailed attacks
};

int main (void)
{
    //Create instances of your fighters
    //menu stuff for turn select and attack choice
    //below is what player 1 kicking player 2 might look like
    
    if (Player1.kickoponent(Player2))
    {
		cout << Player2.GetHealth ();
    }
	
    else
    {
		cout << "Player 1 wins" << endl;
    }

	//and similarly for player 2 attacking player 1

	return 0;
}

Get your console going first on its own, then try out loading it into
a window and displaying basic graphics. Then all the fancy stuff
with buttons can come along.

As far as graphics librarys go, there is some choice, but I've seen
people do amazing looking stuff with openGL in a very short
period of time, so thats the only one I could recommend.

What i meant by console was exactly what you are talking about
in your other post - the "DOS box". You should code your
program so that it appears in the console - simple text menu
indicating what options are available to the player. The user
uses the keyboard to select an option and the program prints
the effect of that option. This is all very basic stuff.

In your other post, you mention that you've studied all the
tutorials on this site. Even if you have studied them in good
detail, very little of that will help you in relation to using the
buttons and the mouse - the Windows API is a very strange
beast. Keep your program simple, like the structure I've laid out,
then build on it to intoduce more moves - and then branching
them out as you wish. All of the attack functions will essentially
be the same, only deducting different amounts from the oponents
health.

If you kept on building the program, you could have a character
select menu, whereby you might code a generic base class
Fighter, with all the functionality that a character needs, then
your list of actual characters could inherit all the basic punches
and kicks from the base, saving you time - because each derived
class would have different values for attributes such as attack
strengths.

Hey all this sounds like fun, might make a basic game such as
this myself after my exams!

For openGL tutorials, one of my friends learned from this site,
and was able to develop some very cool maps and stuff from
it very rapidly.

Actually all the data members are private in Richie's class declaration, which meand that the variables are only accessable by the class itself, and not any other functions, like main() or other classes. That's why Richie declared getter functions. This is good because it protects your data from unauthorized change.

These getter functions make it so that the data is made available to other parts of the program in a safe way. They look something like this:

Code:

// This function returns whatever Health is declared as. Say, an int.
int Fighter::GetHealth(void) const {
    return Health;
}

Somehow missed that last post!

Exactly as citizen said, the variables are private. The reason?
Data encapsulation is one of the principles of good object
oriented design, the idea that the object is a fully self sufficient
entity - the only way to manipulate it being through methods
coded by the programmer. Thats why OOP is so popular in
industry - a class should contain carefully designed methods
so that the code can be reused without need to tinker with the
class's inards. Thats the main difference between classes and
structs - in a struct, all variables are accessible (if an instance is
in scope). In a class, anything under private can only be seen
and changed by the class itself (or friend objects/functions, but
thats another matter). Public means that they are visible to
everyone, so thats why we normally put methods under public.
Protected then has to do with inheritance - where we want
the variables to be restricted like private, but classes
that inherit from this class will inherit variables under protected
as well.