piccola domanda sull OOP

[stdecden]

Salve a tutti!

Ho un problema con l'OOP

Prendiamo il caso di un RPG-Game
Ho un Oggetto Livello, che contiene un Oggetto Player
il Player prende l'input dalla tastiera e si muove di conseguenza, peró prima deve verificare che non ci sia una collisione.

Ed ecco il problema:
mettiamo che la funzione per il rilevamento della collisione é nella classe Livello(bool collide(rect rectangle)). come si fá in c++ ad accedere ad una funzione dell' oggetto padre??? In questo caso Player dovrebbe accedere a collide della classe Livello!?

Magari sbaglio tutto con l'oop e in questo caso sarei molto contento se mi potreste illustrare un'alternativa al mio problema...

[pisto]

cioè se ho capito bene non sai come far testare all'oggetto Player se sta sbattendo contro un muro del livello? beh, se la funzione di Player per muoverlo è muovi() e se all'interno di essa devi controllare prima le collisioni, allora l'oggetto Player deve essere in qualche modo informato in che livello si trova... magari al momento della creazione...

però io, anche se non ho ancora mai creato un qualcosa di così complesso, non sarebbe meglio (o solo + sensato) creare un'entità/oggetto esterno che controlla le collisioni? perché se tipo il Player urta un altro Player, o definisci un modo per notificare ad un Player che è stato urtato, oppure strutturi il tutto facendo che Player è solo un'entità passiva, che si muove e non cerca collisioni finché non gli vengono notificate da questo Dio che trova le collisioni...
magari come funzionalità è lo stesso, ma a me questo modello piace di +

adesso aspetto i pareri dei guru

[PGI-Bis]

La seconda è una questione di C++ più che di orientamento agli oggetti.

Se:

class Livello {
public:
void collide();
};

e:

class Player:public Livello {

};

Allora:

Player p;
p.collide();

Come pure:

class Player:public Livello {

public:
void muovi() {
collide();
}
};

A parole, l'estensione ti permette di considerare i membri non privati di Livello come se fossero dichiarati in Player.

[stdecden]

Grazie per le vostre risposte.

Per programmare un rpg mi consigliate di far muovere i personaggi all'oggetto livello oppure di far si che i Personaggi si regolino da soli. Dovendomi peró cosí incasinare con funzioni e dati degli oggetti "Genitori"

[cionci]

Per programmare un rpg mi consigliate di far muovere i personaggi all'oggetto livello oppure di far si che i Personaggi si regolino da soli. Dovendomi peró cosí incasinare con funzioni e dati degli oggetti "Genitori"
Da nessuno dei due...stai cercando di inserire a forza una funzionalità in un oggetto che non la vuole ;) Ecco perché non ti torna. Se ti fa storcere il naso significa che c'è qualcosa che non va :)

Ad esempio:

//aggiunge nuovi oggetti che vanno creati all'istante indicato dal timer
engine->getLevel()->addNewObjects(timer);
//muove fisicamente gli oggetti
engine->updateObjects(timer);
//fa il check sulle collisioni
engine->checkCollision();
//disegna gli sprite degli oggetti (anche con gli effetti della collisione)
engine->draw();

void Engine::updateObjects(Timer timer)
{
for(list<Object *>::iterator it = objects.begin(); it != objects.end(); it++)
{
(*it)->update(timer);
}
}


Object lo farei molto semplice, l'unica cosa che gli assegnerei sarebbe uno Sprite.

Una cosa del genere:

class Sprite
{
Image data;
double x;
double y;
public:
Sprite(string filename, double x = 0.0L, double y = 0.0L);
void moveTo(double x, double y);
void moveBy(double dx, double dy);
double getX();
double getY();
Image getData();
};


class Object
{
Sprite *sprite;
Engine *engine
public:
Object(Sprite *sprite, Engine *engine);
virtual const Sprite *getSprite();
virtual void update(Timer timer);
};

//ad esempio Player
class Player: public Object
{
int identifier;
Input *input;
list<InputAction> actions;
public:
Player(int identifier, Sprite *sprite, engine): Object(sprite, engine);
virtual void update(Timer timer)
{
// questo metodo privato produce gli InputAction in base allo stato di input
processInput(input, timer);

for(List<InputEvent>::iterator it = actions.begin(); it != actions.end(); it++)
{
(*it).apply();
}
actions.clear();

};

//scrivo la classe InputAction per farti capire

class InputAction
{
public:
InputAction();
virtual void apply() = 0;
};

//scrivo FireAction e MoveLeftAction per farti capire

class FireAction: public InputAction
{
Engine *engine;
public:
FireAction(Engine * engine, int x, int y);
virtual void apply()
{
engine->addObject(new SimpleFire(x, y));
};
};

class MoveLeftAction: public InputAction
{
double speed;
public:
MoveLeftAction(double speed, Object *object);
virtual void apply()
{
object->getSprite()->moveBy(-speed, 0);
};
};

Da notare che queste InputAction con un po' di lavoro possono essere anche Action generiche da applicare agli oggetti generici (come anche astronavi nemiche o spari). Ad esempio Level potrebbe eseguire una sequenza di queste Action a seconda del timer che gli viene passato.
Poi potresti caricare queste Action da un file (con gli istanti e i vari parametri) e così è semplicissimo creare una specie di scripting per i livelli.

[PGI-Bis]

Tempo fa feci un esperimento organizzato in un modo non concretamente diverso da quello proposto da cionci ma, forse, concettualmente diverso.

Ogni elemento del gioco, dai personaggi allo sfondo, è un "Cellula". Una cellula è qualcosa che possiede un riferimento ad un'altra Cellula. Una Cellula è qualcosa di "vivo" e tale vitalità è espressa dalla capacità di reagire ad un impulso.

Insomma una Cellula è semplicemente:

class Cell:
+void shock();
+void link(Cell aCell);
+bool isAlive();

Provai poi ad applicare questo modello ad un gioco esistente (chissà quale :D). Il risultato è che se po' fa. Cioè creando cellule specializzate è possibile realizzare una sorta di organismo che "vive" grazie alla produzione di un impulso da parte di una delle sue cellule.

Che magari non ve ne frega niente ma ve l'ho detto lo stesso :D.

[stdecden]

Grazie mille per le vostre risposte :D.

Mi metteró subito al lavoro e a testare i vostri suggerimenti!!!

[cionci]

Avevo lasciato qualche nome sbagliato a giro ;) Ho corretto...