Repository navigation
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.
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 |
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"]
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.
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
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 tuoupdate()sia già stato eseguito. -
newekill()hanno effetto al successivorefreshObjects(). Nel frattempo un oggetto conkill()può ancora essere aggiornato e disegnato: se serve, controllakilled()o un tuo flag come_dying.Coin, nella sezione 5, usakilled()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.
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);
| 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);
}
}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 suoupdate(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 conunschedule(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 offreunschedule(): scegliidunivoci.
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.
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.
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
Cmostra i collider, il tastoRi 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 diMario, è un salto di posizione che il CCD non vede.
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
_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.
stateDiagram-v2
direction LR
[*] --> Separati
Separati --> InContatto: BEGIN
InContatto --> InContatto: STAY, a ogni passo
InContatto --> Separati: END
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.
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 concollision()eforgetObject(), come l'AreaAttivadella 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.
-
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(), maidelete. La rimozione avviene al successivorefreshObjects(). -
Ricordare: se tieni un puntatore a un altro oggetto, azzeralo in
forgetObject(). La scena lo chiama su tutti gli oggetti prima di distruggerne uno.Hammerricorda 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.
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 lancioLe 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);| 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); // ActionRPGPer 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")));- Ritardi, ripetizioni e cooldown usano
schedule(); sequenze con attese note usanosequence(), 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 catturathis. - 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.
-
HammerBrother.cppeHammer.cpp: scheduler, sequenze, proiettili,collidableWith()eforgetObject(). -
Enemy.cpp,Goomba.cppeCoin.cppdi CustomPlatformerSlopes: un nemico completo in poche righe e un oggetto raccoglibile. -
Soldier.cpp,Link.cppePortal.cppdi ActionRPG:move()eschedule()conoverwrite = false, la spada creata e rimossa a ogni attacco, un trigger che distingue ingresso e uscita. -
Trigger.cppeLevelLoader.cpp: zone e posizionamento nel livello. -
Scheduler.heObject.cpp: come avanzano gli scheduler.
- Panoramica
- Diagramma delle classi
- Architettura e game loop
- Sequenza di un frame
- Input ed eventi
- Scene e oggetti
- Rendering e coordinate
- Sprite e testo
- UI e overlay
- Quadtree
- Servizi e asset
- Estendere il core
- Editor dei livelli
- LevelData e livelli JSON
- Shader