question about classes... maybee

ok this is hard for me to explain... so im gonna break it up if i can...
(sorry for the long post)

im trying to make a game where data is loaded into mem for each different character
this memory i would like to have stored into an array of classes (Character[])

then i would like to be able to make an array of instance classes or something similar to an array of child classes based on one index of each Character[] class, so this array of classes would probably have to be 2d (Player[ , ])

the player[ , ] class should be able to use the data loaded by the Character[] class like below:

player[0,0] and Player[0,1] should have access to the data loaded by Character[0]

player[1,0] and Player[1,1] should have access to the data loaded by Character[1]

so basically:

Player[A,I] has access to Character[A]'s loaded data

SUMMARY:

Character[ ] - used to load and store the character data (model, texture, ect...)

Player[ , ] - keeps track of player values (x,y,z coordinates and weapon)

I Have the Character[ ] class made and working

Im basically trying to figure out how i could set this sort of thing up in c++

WHAT I WAS THINKING OF DOING... BUT AM NOT SURE IF IT WILL WORK:

1:
have the loader put the data into Character[ ] and keep track of how many
characters have been loaded

2:
wait for players to join... and wait for game to begin initialization

3:
create 2d array Player[A,B] with 'A' being the number of characters loaded
and 'B' being the number of players in the game

4:
create a bunch of pointers to the data in Character[ ] for each Player[ , ] index

THE PROBLEM I SEE WITH THAT:

I will almost always end up with a bunch of empty Player classes


This would be alot easier to do if i knew how many different characters there were going to be... but sadly there is no way of me knowing...

Can anyone Think of a more efficient way to do this???

If I follow you correctly, you are saying you want a Character class, and actual character objects would be the different kinds of characters (wolfman, shegirl, godface, etc) that players could choose from. So in that sense, character would me a trait of a player object, right?

Sounds fairly straightforward. I think the 2D array idea is a bad one. You would want two separate 1D array (players, and characters). You just include a pointer to a character object in the player class:

Code:

---

Character *archetype; // or whatchamacallit

---

This points to a pre-existing instance (object) of class Character (such as the shegirl or the godface). You do not need more than one pointer for this.

However, if the character object contains data that can change (eg, how many slimebuckets this godface player has left), then that model needs a slight tweak: rather than using a pointer to the one instance of the specific character archetype, you should initialize the player with a copy of such an object. This way Bobo the Godface can spend slimebuckets without it affecting the number of slimebuckets available to other godface players.

General rule: KEEP IT SIMPLE. As simple as possible. Make simplicity a priority. Do not get unnecessarily complex because you think that will be better. It won't.

Well, I agree to what MK27 has said. Character is better of as a member of Player that can be initialized inside a customized ctor of the Player class.

i.e:

Code:

---

class Player
{
private:
  Character archetype;

public:
  Player(Character &chara):
      archetype(chara)
  {
  }
};

---

Also by doing it this way, you're actually using a dependency injection that is actually a good programming practice.

For the Character objects itself, maybe you should consider using std::vector so you can add items indefinitely.

both ideas sound good to me... but i dont see how making Player the parent to Character will work... i would think it would be the other way around... having Player be a child of Character... I need to only load the data for each character once... and if im understanding the above properly, it seems like i would have to load it for each character...

if i load the character data once for every player i will run out of memory really fast, i cant have that...

how would i go about using std::vector with my classes?

to get a little more complicated in explaining my situation the Character class holds mesh data and the default animation controller for the mesh data (directx9) and i need each instance of the Player class to have its own clone of the default animation controller... this i dont need help with... i just have to figure out the best way to make the Player class... I have to set it up something like this but im not sure how to go about it

Character Class:
Vertex and material data
A function to load from an x file
Any addition functions loading might require
An unused animation controller
Player Class:
A copy of the animation controller
A function to render the model instance
Any player specific data like ammo or position

The only way I see this of working is if in some way Character acts as a base class and Player acts as an instance class... But since im going to have an array of Character classes and an array of Player classes for each index of the Character array, im having trouble determining the best way to set this up

Have you looked up std::vector?
For the second statement, it shouldn't cause problems since it's part of Character and Character would be part of Player.

so u r saying that the way they have told me to do it above Character is both child and parent to Player and Player is both child and parent to Character... I think that is impossible... but my C++ isnt that great...

Quote:

---

Originally Posted by gizmo3

so u r saying that the way they have told me to do it above Character is both child and parent to Player and Player is both child and parent to Character...

---

No, no one told you to do that. What was recommended to you was to make it such that a Player has-a Character. Character would be an abstract base class, but you derive the actual Character subclasses from it.

ok... so i guess im having trouble understanding "archetype" i tried google but i couldnt find anything that really explains how/what "archetype" works/is...

can i has a link plz?

or an explanation?

Where did you get archetype from???

Quote:

---

Originally Posted by MK27

Code:

---

Character *archetype; // or whatchamacallit

---

This points to a pre-existing instance (object) of class Character (such as the shegirl or the godface). You do not need more than one pointer for this.

---

and...

Quote:

---

Originally Posted by g4j31a5

Well, I agree to what MK27 has said. Character is better of as a member of Player that can be initialized inside a customized ctor of the Player class.

i.e:

Code:

---

class Player
{
private:
  Character archetype;

public:
  Player(Character &chara):
      archetype(chara)
  {
  }
};

---

---

It's simply a name. You can call it whatever you will.

DAMN...

now i feel like more of a noob than i did before...

I must be either REALLY tired or REALLY confused...

it seems to me like Player Is-A Character makes more sense than Player Has-A Character

That's because you're confused about your abstractions. A "Character", in your game, is a template, containing stuff like "how does this thing look". A "Player", on the other hand, is a concrete instance. It contains stuff like "where am I".
A Player will typically be an instance of Character, in that there can be many players with the same character, and they have shared properties in the character. However, going from here to "Player is-a Character" is the same fallacy as, given a class Rectangle and an instance myRect, that "myRect is-a Rectangle". It's true in the English language semantics, but in object-oriented thinking, those two things exist on different levels of abstraction.

so if i did something similar to the third post i would only have each different Character loaded once?

The idea here is that each player contains some data. Textures or whatever it is/was.
From this Character class, create instances of it for as many players you need.
If you need different kinds of characters, then derive subclasses from them with specialized properties. Then create instances of those.
Each instance should hold the data it requires to function, put simply.

well... i cannot have it have clones/instances of the data from Character... unless the vars simply point to the data... the data in Character is too big for me to be able to create copies of it... if i could copy it then i would completely get rid of the Character class and only use Player... I need Player class to "leech" off of the data in Character through pointers or something...

Then how about this:
Character (base class which contains all the data that all characters will have) -> Specialized Character (contains data that a special character needs, eg monsters, players).
Now, your specialized classes can use virtual inheritance to inherit from specific character. Using virtual inheritance will ensure that there will only be one instance of the class you inherit from virtually.

sounds like the best idea ive heard yet... how would i go about setting something like that up?

the only problems with that:

there is no such thing as a "Specialized Character"...
in saying this i mean that you are either a human or alien... not human or ninja-human
perhaps you meant to say Player...
in which case the "special data" would be x,y,z position and rotation, weight, and current weapon...
then it would work

Character A and Character B will have almost nothing in common with each other...
for example:

Character A may be a seven foot tall cyborg humaniod
Character B may be a six legged flying insect

Looking at those explainations it is easy to see that almost everything about their animations and abilities will be different

let me explain my problem now in a very simple way:

the characters are like people inside of glass chambers and the players are like clones of those characters which all have their own unique position in space... and they are all performing (can be performing) different actions than both each other and their parent self who is inside of the chamber... like StarWars Clones except the actual Player class only keeps track of their position and other data... like weapon type, or what animation they should be doing

If you were to restate it like this:
Character (base class which contains all appearance data of a single character) -> Player (contains data that defines the actions, location, and status of a single player, eg player1, player2).
Now, your Player classes can use virtual inheritance to inherit from specific character...

then it would be exactly what i need... the only problem is im not going to learn about virtual inheritance until next semester and i would like to be way past this part of my indie game by then...

Code:

---

class Character {};
class Player: virtual public Character {};
class Monster: virtual public Character {};
int main() {}

---

oops... i think it took me too long to edit my previous post... please reread my last post...

I think i might be able to do something like this... but i need a constructor... can anyone help me out with this...

Code:

---

class Player (derived from Character)
{
public:
        Character* Model; //pointer to Character class
        float x; //position on x axis
        float y; //position on y axis
        float z; //position on z axis
        float rx;//rotation on x axis
        float ry;//rotation on y axis
        float rz;//rotation on z axis
};

---

An alien or a monster is obviously not a player. That is why I called it a specialized character.
At this point, it might also turn out that multiple inheritance can be a good choice.
You have the data that you don't want to clone for each instance. So this data should be in a special class that you inherit virtually from.
Then there are other data, such as location, weapon and other stuff that all characters have in common. This should also be in a base class which you inherit from normally.
So something like:

Code:

---

class CCharacter {};
class CVirtualStuff {};
class CPlayer: virtual public CVirtualStuff, public CCharacter {};
class CMonster: virtual public CVirtualStuff, public CCharacter {};
int main() {}

---

But there's nothing wrong about learning these concepts now. It will save you time later.
Heck, you shouldn't be coding a game without a proper understanding of all parts of the language first.

well i figured it would give me better understanding than just doing the same old stupid "Hello World" crap labs that they have you do in class... this way im actually discovering my own ways out of problems... this problem was too hard for that to happen however...

and just for the fun of it... in the game im working on making, all of the monsters, aliens, and soldiers are players... there is pretty much no AI in this game... its all multiplayer!

it seems to me that i would only need Character and player... Character would be virtually inherited i would think...


If someone would help with post 21 it would be awsome...

pretty sure i finally managed to get it to work... for now at least