Skip to content

Starter kit per i contributi

Alessandro Bria edited this page Nov 3, 2026 · 3 revisions

Starter kit per i contributi

Il tuo contributo è una meccanica o un nemico dentro un gioco condiviso dalla classe. Il motore offre già i mattoni per tempi, zone, contatti e forme: usarli rende il codice più corto, lo integra con quello dei compagni e lo rende leggibile a chi lo valuta. Questa pagina li presenta in breve, ciascuno con un frammento di codice; ogni sezione rimanda alla guida dettagliata.

Dove vale. Le regole valgono per CustomPlatformer, CustomPlatformerSlopes e ActionRPG, e i frammenti vengono da tutte e tre. Il commento in testa a un frammento tratto dal repository indica demo e file; quelli senza indicazione sono esempi brevi scritti per questa pagina. In ActionRPG cambiano due dettagli: collision() riceve una normale invece di fromDir e il collider è un RotatedRectF centrato sull'oggetto (vedi la sezione 3).

// CustomPlatformer e CustomPlatformerSlopes: fromDir è il lato del tuo oggetto toccato
virtual bool collision(CollidableObject* with, Contact contact, Direction fromDir) override;

// ActionRPG: normal è la normale del contatto
virtual bool collision(CollidableObject* with, Contact contact, const Vec2Df& normal) override;

In Box2DPlatformer valgono scheduler, creazione e rimozione degli oggetti, sprite, suoni e livello; corpi e contatti seguono invece le regole di Box2D.

Prima di scrivere codice nuovo

Quasi ogni contributo ha bisogno di qualcosa che esiste già. Controlla questa tabella prima di scriverlo da zero.

Ti serve… Usa Invece di
Più azioni con attese note, in ordine sequence() dell'oggetto Catene di schedule() annidati
Un'azione dopo un ritardo, ripetuta o un cooldown schedule() dell'oggetto Contatori di tempo o di frame in update()
Un'azione che deve avvenire anche dopo la rimozione dell'oggetto _scene->schedule() Uno scheduler dell'oggetto che sta per morire
Fare qualcosa quando il giocatore entra in una zona Trigger con una lambda Un oggetto che confronta rettangoli a ogni update()
Reagire al contatto con un altro oggetto collision() e le fasi BEGIN, STAY, END Flag _touching o liste di contatti nella tua classe
Ignorare un certo tipo di oggetto collidableWith() Disattivare _collidable o correggere la posizione a mano
Farti attraversare senza risposta fisica _compenetrable = true Spostare l'altro oggetto fuori dal tuo
Una hitbox diversa dal disegno _collider.adjust(…) Ridimensionare il rect o ritagliare lo sprite
Muovere un nemico _xDir, _xMoveForce, _xVelMax, velAdd(); in ActionRPG move() setPos() a ogni passo
Creare un proiettile o un oggetto raccoglibile new Classe(_scene, …) Liste di oggetti tenute nella tua classe
Eliminare un oggetto kill() delete
Ricordare un altro oggetto Un puntatore azzerato in forgetObject() Un puntatore che resta pendente quando l'altro muore

Quale classe estendere

flowchart TD
    Q1{"Si muove?"} -->|"con gravità e collisioni"| D["Enemy o DynamicObject<br/>nemici, proiettili, power-up"]
    Q1 -->|"su un percorso, trasportando altri"| K["KinematicObject, come Lift<br/>solo nei platformer"]
    Q1 -->|no| Q2{"Reagisce a un contatto?"}
    Q2 -->|"solo il giocatore, un'azione all'ingresso"| T["Trigger con una lambda,<br/>creato nel LevelLoader"]
    Q2 -->|"con stato o con più oggetti"| S["StaticObject compenetrabile<br/>che ridefinisce collision"]
    Q2 -->|no| R["RenderableObject<br/>decorazione o effetto"]
Loading

Per un nemico, estendi l'Enemy del tuo progetto: la sua collision() gestisce già i casi comuni a tutti i nemici, come ferire Mario o essere schiacciato da un Mario invincibile. Lo scheletro è quello di Goomba: un costruttore che fissa rect, sprite, movimento e collider, più l'override dei soli metodi che cambiano.

// MioNemico.h, sul modello di Goomba.h (CustomPlatformerSlopes)
#pragma once

#include "Enemy.h"

namespace agp
{
    class MioNemico;
}

class agp::MioNemico : public Enemy
{
    public:

        MioNemico(Scene* scene, const PointF& pos, int layer = 3);

        // estende la logica di gioco: chiama prima Enemy::update(dt)
        virtual void update(float dt) override;

        virtual std::string name() override { return strprintf("MioNemico[%d]", _id); }
};

// MioNemico.cpp
#include "MioNemico.h"
#include "SpriteFactory.h"

using namespace agp;

MioNemico::MioNemico(Scene* scene, const PointF& pos, int layer)
    : Enemy(scene, RectF(pos.x, pos.y, 1.0f, 1.0f), nullptr, layer)
{
    _sprite = SpriteFactory::instance()->get("mio_nemico_walk");
    _xDir = Direction::LEFT;
    _xVelMax = 2;
    _xMoveForce = 1000;
    _collider.adjust(0.2f, 0, -0.2f, -1 / 16.0f);
}

void MioNemico::update(float dt)
{
    Enemy::update(dt);

    // la logica propria del nemico: posizione e contatti sono già aggiornati
}

In ActionRPG lo scheletro è lo stesso: cambiano la firma di collision() e il tipo del rect, perché l'Enemy di ActionRPG riceve un RotatedRectF. Soldier gli passa comunque un RectF(pos.x, pos.y, 1.625f, 2), che viene convertito. Il ramo «StaticObject compenetrabile» del diagramma è Coin, nella sezione 5.

1. Quando gira il tuo codice

sequenceDiagram
    participant S as GameScene
    participant O as Il tuo oggetto
    S->>S: refreshObjects: entrano gli oggetti creati, escono quelli con kill
    S->>S: scheduler della scena, con il tempo del frame
    loop ogni passo fisso dt
        S->>O: update(dt)
        O->>O: Object::update: scheduler dell'oggetto
        O->>O: MovableObject: forze e velocità
        O->>O: CollidableObject: collisioni e contatti
        O-->>O: collision(with, BEGIN, STAY o END, fromDir)
        O->>O: il tuo codice dopo la chiamata alla classe base
    end
Loading

Tre conseguenze pratiche:

  • I task degli scheduler dell'oggetto partono all'inizio del suo update(), prima della fisica.
  • collision() può arrivare anche mentre si aggiorna l'altro oggetto: BEGIN ed END vengono notificati a entrambi. Non presupporre che il tuo update() sia già stato eseguito.
  • new e kill() hanno effetto al successivo refreshObjects(). Nel frattempo un oggetto con kill() può ancora essere aggiornato e disegnato: se serve, controlla killed() o un tuo flag come _dying. Coin, nella sezione 5, usa killed() per non contare due volte la stessa moneta.

Nel tuo update() il codice scritto dopo la chiamata alla classe base vede posizione e contatti già aggiornati. HammerBrother decide dove guardare solo dopo Enemy::update():

// CustomPlatformer, HammerBrother.cpp (estratto)
void HammerBrother::update(float dt)
{
    Enemy::update(dt); // scheduler, forze, collisioni e contatti di questo passo

    Mario* mario = dynamic_cast<Mario*>(dynamic_cast<PlatformerGameScene*>(_scene)->player());
    if (mario->rect().center().x > rect().center().x)
        _facingDir = Direction::RIGHT;
    else
        _facingDir = Direction::LEFT;
}

Il codice scritto prima della chiamata prepara invece il passo. Sword di ActionRPG si sistema accanto a Link e aggiorna il collider, poi lascia lavorare la fisica:

// ActionRPG, Sword.cpp (estratto)
void Sword::update(float dt)
{
    _facingDir = _link->facingDir();
    // ... posizione e collider allineati a Link e all'animazione

    DynamicObject::update(dt);
}

Il diagramma completo è in Sequenza di un frame.

2. Scheduler dell'oggetto e della scena

schedule(id, ritardo, task, loop, overwrite) esegue task dopo ritardo secondi. HammerBrother di CustomPlatformer costruisce il suo comportamento solo con scheduler. Il lancio dei martelli è uno schedule() ripetuto che a ogni giro decide se lanciare; i due passi del lancio formano una sequence(), descritta più sotto.

// CustomPlatformer, HammerBrother.cpp: ogni 0.7 s circa tenta un lancio (4 volte su 5), per sempre: loop = -1
schedule("spawnHammer", 0.7f + (rand() % 100) / 1000.0f, [this]
    {
        if (rand() % 5 > 0 && !_dying)
            sequence("throwHammer", {
                {0.0f, [this]()
                    {
                        // il primo passo parte al prossimo update: nel frattempo può essere morto
                        if (_dying)
                            return;
                        new Hammer(_scene, rect().tl(), this);
                        _throwing = true;
                    }},
                {0.5f, [this]() { _throwing = false; }}
            });
    }, -1);
Scheduler: con loop 0 il task scatta una volta, con loop 2 tre volte, con loop -1 finché l'oggetto viene rimosso; uno scheduler della scena scatta anche dopo la rimozione
Parametro Significato
id Nome dell'azione. Lo stesso id sostituisce l'azione precedente: con overwrite = true (default) il conto alla rovescia riparte.
ritardo Secondi prima della prima esecuzione e fra due ripetizioni. Può essere zero per eseguire al prossimo update; per ripetizioni temporizzate usa un valore positivo.
loop 0 una volta; N una volta più N ripetizioni; -1 per sempre.
overwrite false lascia correre un timer già attivo con lo stesso id: Soldier di ActionRPG lo usa per non rimandare all'infinito il sonno.

Soldier chiama schedule() a ogni update mentre dorme: con overwrite = false resta valido il primo timer. Quando Link si avvicina, unschedule() cancella il risveglio programmato:

// ActionRPG, Soldier::AI() (estratto), chiamata a ogni update
if (_state == State::SLEEP)
{
    if (distanceFromLink > 5)
        schedule("wake", float(1 + rand() % 5), [this]() { changeState(State::PATROL); }, 0, false);
    else
    {
        unschedule("wake");
        changeState(State::CHASING);
    }
}

Una sequenza leggibile, senza annidamenti

Quando le attese sono note, Object::sequence(id, steps) traduce una lista di coppie attesa, azione in normali schedule(). Per esempio, in una sottoclasse di RenderableObject:

sequence("comparsa", {
    {0.0f, [this]() { setVisible(false); }},
    {2.0f, [this]() { setVisible(true); }},
    {1.0f, [this]() { kill(); }}
});

Le scadenze sono 0, 2 e 3 secondi dall'avvio della sequenza: ogni attesa si somma alle precedenti. Il primo passo a zero parte al prossimo Object::update(), non durante la chiamata a sequence(). I passi scaduti nello stesso update vengono eseguiti nell'ordine della lista, anche se il frame supera più scadenze.

  • Una nuova sequence("comparsa", ...) sostituisce tutti i passi ancora in attesa della precedente, anche se la nuova lista è più corta.
  • unscheduleSequence("comparsa") annulla i passi rimasti. Una lista vuota ha lo stesso effetto. unschedule() continua invece a cancellare un singolo scheduler.
  • La sequenza appartiene all'oggetto: segue i suoi update, si ferma quando viene congelato e scompare quando viene distrutto. Dopo kill() non vengono eseguiti altri passi dell'oggetto.
  • Le callback possono annullare o riavviare la propria sequenza. I nuovi scheduler creati da una callback iniziano dal prossimo update dell'oggetto.
  • Usa nomi distinti, senza sovrapporre i prefissi: comparsa/ è riservato ai passi interni. Non usarlo per altri scheduler o sequenze.

Le attese devono essere finite e non negative, e ogni azione deve essere valida; altrimenti viene lanciata std::invalid_argument senza sostituire la sequenza precedente. sequence() è disponibile su Object, non su Scene.

La sequenza misura il tempo, non la conclusione delle azioni: se un passo avvia un'animazione, il successivo non ne rileva automaticamente la fine. Se il passaggio dipende da una condizione, usa callback o funzioni con nomi chiari e mantieni il concatenamento necessario. In HammerBrother, sopra, la decisione a ogni lancio resta in uno schedule() ripetuto; la sequence() contiene solo i passi con attese note.

Oggetto o scena?

  • schedule() dell'oggetto avanza nel suo update(dt), a passo fisso. Si ferma se l'oggetto è congelato e scompare con l'oggetto: un task in attesa di un oggetto rimosso non viene mai eseguito. Si annulla con unschedule(id).
  • _scene->schedule() avanza con il tempo del frame e si ferma solo quando la scena non viene aggiornata, per esempio durante il menu di pausa. Serve per ciò che deve accadere dopo la rimozione dell'oggetto, come un respawn. La scena non offre unschedule(): scegli id univoci.

Un task della scena può essere eseguito quando l'oggetto che lo ha creato non esiste più. Quindi non catturare this: cattura per valore ciò che serve.

// nel nemico che muore: ricompare dopo 3 secondi nello stesso punto
Scene* scene = _scene;
PointF spawn = pos();
_scene->schedule(strprintf("respawn%d", _id), 3, [scene, spawn]() { new Goomba(scene, spawn); });

Non contare i frame e non accumulare dt a mano per misurare il tempo: è proprio quello che fa lo scheduler. Approfondimento: Scene, oggetti e scheduling.

3. Il collider dentro il rect

Ogni oggetto ha un rect, l'area in cui si disegna lo sprite e che si sposta con l'oggetto. Un oggetto collidibile ha anche un collider, la forma usata dalle collisioni. Il collider è espresso in coordinate dell'oggetto: l'origine è l'angolo rect().pos e y cresce verso il basso. Per default coincide con il rect (defaultCollider()); in scena vale sceneCollider() = _collider + rect().pos.

Collider dentro il rect: Goomba con collider ristretto, Super Mario in piedi e accucciato

Lo sprite contiene quasi sempre un margine trasparente. Si restringe il collider nel costruttore con adjust(dx1, dy1, dx2, dy2), che sposta l'angolo in alto a sinistra di (dx1, dy1) e quello in basso a destra di (dx2, dy2):

// CustomPlatformerSlopes, Goomba.cpp
Goomba::Goomba(Scene* scene, const PointF& pos, int layer)
    : Enemy(scene, RectF(pos.x, pos.y, 1.0f, 1.0f), nullptr, layer)
{
    // ... sprite e parametri di movimento
    _collider.adjust(0.2f, 0, -0.2f, -1 / 16.0f); // 0.2 per lato, 1/16 in basso
}

Il collider può cambiare durante il gioco: in CustomPlatformerSlopes Mario::crouch() abbassa la cima di 0.55 e la rialza all'uscita. Sono variazioni simmetriche: ciò che crouch(true) toglie, crouch(false) restituisce.

// CustomPlatformerSlopes, Mario.cpp
void Mario::crouch(bool on)
{
    if (midair() || !_super || _crouch == on || _transformSuper2Small)
        return;

    _crouch = on;

    if (on)
        _collider.adjust(0, 0.55f, 0, 0);
    else
        _collider.adjust(0, -0.55f, 0, 0);
}

In ActionRPG il collider è un RotatedRectF riferito al centro del corpo: sceneCollider() vale _collider + _rrect.center. Per restringerlo si cambia size, e il collider resta centrato:

// ActionRPG, Soldier.cpp: collider 0.8 x 0.8 al centro di un rect 1.625 x 2
_collider.size.x = 0.8f;
_collider.size.y = 0.8f;

Attenzione a tre cose:

  • Verifica sempre a schermo: in gioco il tasto C mostra i collider, il tasto R i rect.
  • Allargare il collider è un teletrasporto della forma: se lo spazio è occupato, ad esempio rialzandosi sotto un soffitto, il collider nasce dentro un altro oggetto, una situazione che il CCD non sa risolvere. Controlla prima che lo spazio sia libero.
  • Non cambiare il rect per cambiare la hitbox: setRect() sposta anche il disegno e, come segnalano i commenti di Mario, è un salto di posizione che il CCD non vede.

4. Collisione fisica e collisione logica

Le collisioni hanno due livelli. Quello fisico è automatico: il solver ferma il movimento contro i collider solidi. Quello logico è tuo: in collision() decidi che cosa significa il contatto per il gioco, ad esempio danno, raccolta o rimbalzo. Tre impostazioni stabiliscono che cosa succede fra due oggetti:

flowchart TD
    A{"Entrambi _collidable?"} -->|no| N["Nessuna collisione, nessun evento"]
    A -->|sì| B{"collidableWith accetta la coppia,<br/>da entrambe le parti?"}
    B -->|no| N
    B -->|sì| C{"L'altro oggetto<br/>è _compenetrable?"}
    C -->|no| P["Risposta fisica:<br/>il movimento si ferma sul suo collider"]
    C -->|sì| Q["Nessuna risposta fisica:<br/>lo attraversi"]
    P --> E["collision: BEGIN, STAY, END"]
    Q --> E
Loading

_collidable = false spegne tutto, compresi gli eventi. HammerBrother lo usa per mezzo secondo durante il salto, con uno scheduler che lo riaccende:

// CustomPlatformer, HammerBrother.cpp (estratto dello scheduler "jump")
velAdd(Vec2Df(0, -_yJumpImpulse));
_collidable = false;
schedule("collidable_on", 0.5f, [this]() { _collidable = true; });

collidableWith() filtra per tipo: Hammer accetta solo Mario, Sword di ActionRPG solo i nemici, un Goomba schiacciato ignora gli altri oggetti dinamici e lascia il resto a Enemy.

// CustomPlatformer, Hammer.cpp
bool Hammer::collidableWith(CollidableObject* obj)
{
    return dynamic_cast<Mario*>(obj);
}

// ActionRPG, Sword.h
virtual bool collidableWith(CollidableObject* obj) override { return obj->to<Enemy*>(); }

// CustomPlatformerSlopes, Goomba.cpp
bool Goomba::collidableWith(CollidableObject* obj)
{
    if (_stomped && dynamic_cast<DynamicObject*>(obj))
        return false;
    else
        return Enemy::collidableWith(obj);
}

_compenetrable toglie solo la risposta fisica e si imposta nel costruttore. Gli oggetti dinamici lo sono per default: due nemici non si spingono a vicenda. In CustomPlatformerSlopes si accorgono del contatto in collision() e invertono la marcia:

// CustomPlatformerSlopes, Coin.cpp (costruttore): la moneta si attraversa
_compenetrable = true;

// CustomPlatformerSlopes, Enemy::collision() (estratto): chi tocca un ostacolo
// o un altro nemico dal lato verso cui cammina inverte la marcia
if (contact != Contact::END && _xDir != Direction::NONE && (staticObj || enemy || kinObj) && fromDir == _xDir)
{
    _xDir = inverse(_xDir);
    return true;
}

Il valore restituito da collision() dice se hai gestito l'interazione: restituire false non annulla la risposta fisica.

5. I contatti: BEGIN, STAY, END

stateDiagram-v2
    direction LR
    [*] --> Separati
    Separati --> InContatto: BEGIN
    InContatto --> InContatto: STAY, a ogni passo
    InContatto --> Separati: END
Loading

Il motore tiene la lista dei contatti al posto tuo e ti comunica la fase. Scegli la condizione in base all'intenzione:

Intenzione Condizione Esempio
Una volta all'ingresso contact == Contact::BEGIN Raccogliere una moneta, colpire con la spada
Ingresso e permanenza contact != Contact::END Un nemico che ferisce Mario
Solo durante la permanenza contact == Contact::STAY Un effetto continuo
All'uscita contact == Contact::END Spegnere un effetto, riarmare un portale

fromDir è il lato del tuo oggetto toccato: un personaggio sopra una piattaforma riceve DOWN. Su END vale NONE. BEGIN vale una volta per contatto, non per partita: se l'oggetto rientra, arriva un nuovo BEGIN. Per sparire dopo la raccolta, chiama anche kill().

Una volta all'ingresso. Coin è uno StaticObject compenetrabile che ridefinisce collision(): il ramo corrispondente del diagramma «Quale classe estendere». In ActionRPG l'Enemy muore al BEGIN con la spada.

// CustomPlatformerSlopes, Coin.cpp
bool Coin::collision(CollidableObject* with, Contact contact, Direction fromDir)
{
    Mario* mario = dynamic_cast<Mario*>(with);
    if (!mario || contact != Contact::BEGIN || killed())
        return false;

    dynamic_cast<PlatformerGame*>(Game::instance())->hud()->addCoin();

    kill();

    return true;
}

// ActionRPG, Enemy.cpp
bool Enemy::collision(CollidableObject* with, Contact contact, const Vec2Df& normal)
{
    DynamicObject::collision(with, contact, normal);

    if (contact == Contact::BEGIN && with->to<Sword*>())
        kill();

    return false;
}

Ingresso e permanenza: il nemico di CustomPlatformer ferisce Mario finché lo tocca.

// CustomPlatformer, Enemy.cpp
bool Enemy::collision(CollidableObject* with, Contact contact, Direction fromDir)
{
    Mario* mario = dynamic_cast<Mario*>(with);

    if (mario && contact != Contact::END)
    {
        if (_smashable && mario->invincible())
            smash();
        else
            mario->hurt();

        return true;
    }

    return false;
}

Permanenza e uscita. Nessuna demo reagisce al solo STAY, ma KinematicObject nei platformer lo usa insieme a BEGIN per tenere aggiornato il passeggero e lo dimentica su END. Il Portal di ActionRPG si riarma all'uscita, così il giocatore appena arrivato non viene rispedito indietro:

// CustomPlatformerSlopes, KinematicObject.cpp (estratto): BEGIN e STAY aggiornano, END rimuove
DynamicObject* dobj = with->to<DynamicObject*>();
if (dobj)
{
    if (contact == Contact::END)
        _collidingItems.erase(dobj);
    else
        _collidingItems[dobj] = fromDir;
    return true;
}

// ActionRPG, Portal.cpp (estratto)
bool Portal::collision(CollidableObject* with, Contact contact, const Vec2Df& normal)
{
    if (with == _watched && _playerArrived && contact == Contact::END)
        _playerArrived = false;
    else if (with == _watched && !_playerArrived && contact == Contact::BEGIN)
    {
        // ... congela il giocatore, avvia la transizione e teletrasporta dopo 1 s
    }

    return true;
}

Per un effetto che dura nel tempo, applicalo nel tuo update(dt) mentre il contatto è attivo, moltiplicando per dt: non contare le chiamate a STAY come se fossero secondi. Guida completa ed esempio della zona attiva: Usare Contact: BEGIN, STAY, END.

6. Trigger: una zona che esegue un'azione

Trigger è un collider invisibile e compenetrabile che osserva un solo oggetto e chiama una lambda su ogni suo BEGIN. Si crea nel LevelLoader, dopo il giocatore. In CustomPlatformerSlopes una striscia sotto il livello fa morire Mario quando cade:

// CustomPlatformerSlopes, LevelLoader.cpp
Mario* mario = world->player()->to<Mario*>();
new Trigger(world, RectF(world->rect().left(), 4, world->rect().size.x, 0.1f), mario,
    [mario]() { mario->die(); });

Ecco cosa riceve un Trigger quando il giocatore lo attraversa, esce e rientra:

Passo 1 2 3 4 5 6 7
Giocatore fuori dentro dentro fuori fuori dentro dentro
Evento – BEGIN STAY END – BEGIN STAY
Task eseguito ✔ ✔

Gli altri oggetti che lo attraversano non eseguono il task. Due attenzioni:

  • Il task riparte a ogni ingresso. Per un evento unico, come risvegliare un boss, rendi idempotente l'azione chiamata, ad esempio con un flag nel boss.
  • La lambda non riceve forgetObject(). Cattura soltanto oggetti che vivono quanto il trigger, come il giocatore o gli elementi del livello. Se il bersaglio può essere rimosso, scrivi una classe con collision() e forgetObject(), come l'AreaAttiva della guida ai contatti.

In CustomPlatformer la lambda cattura per valore i lift del livello, che vivono quanto il trigger, e a ogni ingresso li avvia o li ferma:

// CustomPlatformer, LevelLoader.cpp
if (!lifts.empty())
    new Trigger(world, RectF(1, -12, 0.5f, 13), world->player()->to<CollidableObject*>(), [lifts]()
        {
            for (auto lift : lifts)
                lift->toggleFreezed();
        });

In ActionRPG il costruttore riceve un RotatedRectF. Portal, nella sezione 5, è un Trigger che ridefinisce collision() per distinguere l'ingresso dall'uscita.

7. Creare, rimuovere e ricordare oggetti

  • Creare: new Hammer(_scene, rect().tl(), this);. Il costruttore registra l'oggetto nella scena, che lo possiede: non conservarlo in una lista tua solo per distruggerlo.
  • Rimuovere: kill(), mai delete. La rimozione avviene al successivo refreshObjects().
  • Ricordare: se tieni un puntatore a un altro oggetto, azzeralo in forgetObject(). La scena lo chiama su tutti gli oggetti prima di distruggerne uno. Hammer ricorda chi lo ha lanciato:
// CustomPlatformer, Hammer.cpp
void Hammer::forgetObject(Object* objectToRemove)
{
    Enemy::forgetObject(objectToRemove);
    if (objectToRemove == _thrower)
    {
        _thrower = nullptr;
        if (!_throwing)
            kill(); // un martello ancora in mano sparisce con il lanciatore
    }
}

Link di ActionRPG fa tutte e tre le cose con la spada: la crea a ogni attacco, la ricorda in _sword e la rimuove a fine animazione.

// ActionRPG, Link.cpp (estratto)
void Link::attack()
{
    if (_attacking)
    {
        _sprite->reset();
        if (_sword)
            _sword->kill(); // un nuovo attacco rimuove la spada precedente
    }

    _sword = new Sword(this);
    _attacking = true;
    schedule("attack_off", dynamic_cast<AnimatedSprite*>(_sprites[int(_facingDir)]["attack"])->duration(), [this]()
        {
            _attacking = false;
            if (_sword)
                _sword->kill();
            _sword = nullptr;
        });
}

void Link::forgetObject(Object* objectToRemove)
{
    DynamicObject::forgetObject(objectToRemove);
    if (objectToRemove == _sword)
        _sword = nullptr;
    if (objectToRemove == _shadow)
        _shadow = nullptr;
}

Dettagli: ciclo di vita di un oggetto.

8. Muovere un nemico

Non spostare un corpo fisico con setPos() a ogni passo: salteresti la risoluzione delle collisioni. Imposta i parametri di MovableObject e lascia lavorare la fisica:

// nei platformer, per esempio nel costruttore
_xDir = Direction::LEFT; // direzione di marcia; NONE per fermarsi
_xMoveForce = 1000;      // accelerazione
_xVelMax = 2;            // velocità massima, unità di scena al secondo
_yGravityForce = 25;     // 0 per un oggetto che vola
velAdd(Vec2Df(0, -9));   // impulso, per esempio un salto o un lancio

Le interrogazioni midair(), grounded() e falling() descrivono lo stato del corpo. HammerBrother salta solo da terra:

// CustomPlatformer, HammerBrother.cpp (estratto dello scheduler "jump")
if (!midair() && rand() % 2 && !_dying)
    velAdd(Vec2Df(0, -_yJumpImpulse));

In ActionRPG, con la vista dall'alto, i parametri sono vettori (_moveForce, _velMax) e il comando è move(xDir, yDir). Soldier raggiunge il prossimo punto del percorso prima in verticale, poi in orizzontale:

// ActionRPG, Soldier.cpp (estratto)
_velMax = { 2, 2 }; // in pattuglia; 3.5 quando insegue Link

if (std::fabs(_target.y - sceneCollider().center.y) > 0.1f)
    move(Direction::NONE, vec2dir(Vec2Df(0, _target.y - sceneCollider().center.y)));
else if (std::fabs(_target.x - sceneCollider().center.x) > 0.1f)
    move(vec2dir(Vec2Df(_target.x - sceneCollider().center.x, 0), 0), Direction::NONE);

9. Risorse e collegamenti al resto del gioco

Ti serve Come Dove
Uno sprite o un'animazione Registra _creators["mio_nemico_walk"] in SpriteFactory::init(), poi SpriteFactory::instance()->get("mio_nemico_walk") Sprite, animazioni e testo
Un suono Aggiungi il WAV nella cartella sounds/ del progetto, poi Audio::instance()->playSound("NomeFile") Servizi e risorse
Il giocatore dynamic_cast<GameScene*>(_scene)->player(), poi ->to<Mario*>() o ->to<Link*>() GameScene.h
Punteggio e HUD dynamic_cast<PlatformerGame*>(Game::instance())->hud(); in ActionRPG RPGGame PlatformerGame.h, RPGGame.h, HUD.h
Posizionarlo nel livello Una categoria nell'editor e un ramo in LevelLoader::loadJson() Estendere il core
// CustomPlatformerSlopes, SpriteFactory::init(): animazione di due fotogrammi 16 x 16 a 8 fotogrammi al secondo
_creators["goomba_walk"] = [this]
{
    std::vector<RectI> rects;
    RectI anchor(1, 1, 16, 16);
    rects.push_back(anchor);
    rects.push_back(moveBy(anchor, 1, 0, 16, 16, 1, 1));
    return new AnimatedSprite(_spriteSheets["enemies"], rects, 8);
};

// nel costruttore dell'oggetto
_sprite = SpriteFactory::instance()->get("goomba_walk");

// un suono: il nome del file WAV, senza estensione
Audio::instance()->playSound("Stomp");           // CustomPlatformerSlopes, sounds/Stomp.wav
Audio::instance()->playSound("fighter sword 1"); // ActionRPG, sounds/fighter sword 1.wav

// il giocatore
Mario* mario = dynamic_cast<GameScene*>(_scene)->player()->to<Mario*>(); // Link* in ActionRPG

// l'HUD: i metodi disponibili sono in HUD.h di ciascuna demo
dynamic_cast<PlatformerGame*>(Game::instance())->hud()->addCoin(); // CustomPlatformerSlopes
dynamic_cast<RPGGame*>(Game::instance())->hud()->setCoins(10);     // ActionRPG

Per posizionare l'oggetto dal livello, aggiungi un ramo nel LevelLoader. Gli eventuali parametri si leggono dall'oggetto JSON, come il percorso di pattuglia di Soldier:

// CustomPlatformerSlopes, LevelLoader::loadJson() (estratto)
else if (category == "Goomba")
    new Goomba(world, rect.pos);

// ActionRPG, LevelLoader::loadJson() (estratto)
else if (category == "Soldier")
    new Soldier(world, rrect.toRect().pos, LevelData::rect(jObj.at("patrolRect")));

Checklist prima del merge

  • Ritardi, ripetizioni e cooldown usano schedule(); sequenze con attese note usano sequence(), senza contatori scritti a mano.
  • Le reazioni ai contatti stanno in collision() e scelgono la fase giusta.
  • I filtri per tipo stanno in collidableWith().
  • Il collider è stato controllato a schermo con il tasto C.
  • Ogni puntatore ad altri oggetti è azzerato in forgetObject(); nessun task della scena cattura this.
  • Gli oggetti si rimuovono con kill().
  • Il nuovo elemento si posiziona dal livello, con una categoria e il loader, non con coordinate scritte nel codice.

Esempi da leggere nel repository

Clone this wiki locally