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.

It would be considerably harder to make it a networked game.
I assume that you are eventually aiming to make this a basic
street fighter style game, with characters moving at the same
time - then you would have to look at multi-threading. Also
if it was online, the program would also ahave to simultaneously
update each players screen very rapidly. The truth is that it
is not impossible, but you would need years of experience to
be able to wite a program of that calibre, and a lot of time if you
were doing it on your own too! Not trying to dishearten you,
but you need to have realistic goals, otherwise you will get very
disappointed very quickly.

Also, I am on MSN but I prefer not to use it - if you have a
question, I don't mind the PM but I can't be guaranteed to be able
to help, so it may sometimes be a better idea to post questions
here. My advice is as always, not to give in at the first stumbling
block with problems you encounter - perseverence pays off big
time in developing good coding experience, but when you are
really stuck, then you need help.

Good luck with the game - take it slow!

Yes i see. Well the good news is that it sounds considerably
easier than what I thought you were working towards. Classes
deinitely seem to be the best tool for this job - when you get
handy with them you will see that you could store the fighter's
current status (open/closed play), the other oponents choices
can affect your current characters status.

It sounds like that the only hard part of the program will be
working out your menu structures. The program is definitely
going to be a work in progress for a while, but all of your attack
functions will be similar, but coding all the details of all the
character unique data will be tedious. Sounds like a solid task
in program design structure - the individual parts of the code
to do the various things will be easy, but arranging it well will
be a challenge.

Well its all a matter of design choice really. Adrenaline is a good
idea - remember in fighting games where you have to build up
a status bar by making powerful attatcks, and when you reach
a high enough level, you can pull of a special move?

Your classes are going to be of a similar form as the one I
posted earlier, so I'll just show you an implementation of one of
the functions in in it, whereby a player kicks another player.

here's the class again

Code:

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

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

Now an implementation of kickoponent:

Code:

bool Fighter::kickoponent(Fighter &oponent)
{
	if (oponent.health <= kickstrength)
	{
		oponent.health = 0;
		return false	//oponent is dead!
	}

	oponent.health -= kickstrength;	//performing damage of amount kickstrength
	adrenaline += 10;	        //increasing adrenaline by some amount
	return true;	                //player still has some health, so let main know about it
}

I mentioned inheritance earlier, and it is a good application of it.
What you would do would be to write a base class with some
very basic functionality, such as basic moves such as punches
and kicks, methods to return the health and so on. Then
you can create a whole bunch of classes which inherit all this
functionality and can implement extra things such as player
specific moves. Each class will inherit the same types of attributes
but can have different values for those attributes - one character
can have stronger kicks than another, but the code that executes
a kick is the same - you only write it once!

You should get started on implementing the above class - just
do one class type and test it out in a program that looks like the
pseudo-program I posted earlier.