Les minuteries sont indispensables dans la plupart des jeux, car à chaque période donnée, la fonction de rafraîchissement correspondante est exécutée pour mettre à jour l'écran du jeu, l'heure, la progression, les instructions de l'ennemi, etc.
Cocos2d-x nous fournit des opérations liées à la planification du minuteur. La fonction d'opération est définie dans CCNode, donc la plupart des classes de moteur peuvent définir des minuteries, telles que CCLayer, CCSprite, CCMenu, etc.
Il existe trois types de méthodes de mise à jour du minuteur:
(1) La minuterie par défaut: scheduleUpdate ();
(2) Minuterie personnalisée: programme ();
(3) Minuterie unique: scheduleOnce ();
Calendrier de la minuterie, update.rar
scheduleUpdate
Minuterie par défaut: scheduleUpdate ().
Les temps de rafraîchissement par défaut du minuteur sont liés à la fréquence de rafraîchissement de l'écran. Si la fréquence est de 60 images par seconde, alors scheduleUpdate effectue 60 rafraîchissements par seconde.
Le corps de la fonction de rafraîchissement correspondant à scheduleUpdate est update (), c'est-à-dire que la fonction update () est exécutée une fois par image.
Les opérations associées sont les suivantes:
//
// Active la minuterie par défaut. L'intervalle de rafraîchissement est d'une image.
void scheduleUpdate ();
void scheduleUpdateWithPriority (int priority); // Donner la priorité. Plus la priorité est petite, plus la priorité est élevée
virtual void update (float delta); // update est le corps de la fonction de rafraîchissement de la minuterie scheduleUpdate.
//
programme
Minuterie personnalisée: programme ().
Le minuteur peut personnaliser le corps de la fonction de rafraîchissement désigné, le nombre de corps de la fonction de rafraîchissement, la fréquence de rafraîchissement et l'heure de démarrage de l'actualisation.
Le corps de la fonction n'est pas nécessairement update (), vous pouvez le définir vous-même.
Les opérations associées sont les suivantes:
//
// Définit un minuteur personnalisé. L'intervalle d'actualisation par défaut est d'une image.
// intervalle: Exécute une fois toutes les secondes d'intervalle.
// répétition: nombre de répétitions.
// delay: temps de retard, c'est-à-dire que l'actualisation commencera après la création des secondes de retard du minuteur.
// planning (schedule_selector (HelloWorld :: myUpdate), 1.0 / 60.0);
void schedule (SEL_SCHEDULE selector); // L'intervalle de rafraîchissement par défaut est d'une image
void schedule (SEL_SCHEDULE selector, float interval); // Intervalle de rafraîchissement personnalisé, unité: seconde
programme vide (sélecteur SEL_SCHEDULE, intervalle flottant, répétition int non signée, délai flottant);
//
calendrierUne fois
Minuterie unique: scheduleOnce ().
Le minuteur n'exécute le corps de la fonction d'actualisation qu'une seule fois après avoir attendu le second délai de retard, puis ne s'actualise pas à nouveau.
Les opérations associées sont les suivantes:
//
// Exécuter une seule fois, exécuter après un délai de secondes
// scheduleOnce (schedule_selector (HelloWorld :: myUpdate), 5.0);
void scheduleOnce (sélecteur SEL_SCHEDULE, délai flottant);
//
Autres opérations
Annulation, pause et reprise de la minuterie.
Les opérations associées sont les suivantes:
//
// ceci-> unscheduleUpdate ();
// sprite-> unscheduleAllSelectors ();
void unscheduleUpdate (void); // Annule le minuteur par défaut
void unschedule (sélecteur SEL_SCHEDULE); // Annule le minuteur de la fonction personnalisée
void unscheduleAllSelectors (void); // Annule tous les minuteurs
void pauseSchedulerAndActions (void); // Suspend tous les minuteurs et actions
void resumeSchedulerAndActions (void); // Reprend tous les minuteurs et actions
//
Combat de code
1. Créez cinq elfes dans HelloWorld :: init ()
Il existe une correspondance univoque entre l'assistant et cinq méthodes de définition des minuteries.
//
// Créer cinq sprites
CCSprite * sp = CCSprite :: create ("Icon.png");
sp-> setPosition (ccp (30, mysize.height - 30));
this-> addChild (sp, 0, 100); // balise balise 100
CCSprite * sp1 = CCSprite :: create ("Icon.png");
sp1-> setPosition (ccp (30, mysize.height - 90));
this-> addChild (sp1, 0, 101); // balise balise 101
CCSprite * sp2 = CCSprite :: create ("Icon.png");
sp2-> setPosition (ccp (30, mysize.height - 150));
this-> addChild (sp2, 0, 102); // balise balise 102
CCSprite * sp3 = CCSprite :: create ("Icon.png");
sp3-> setPosition (ccp (30, mysize.height - 210));
this-> addChild (sp3, 0, 103); // balise balise 103
CCSprite * sp4 = CCSprite :: create ("Icon.png");
sp4-> setPosition (ccp (30, mysize.height - 270));
this-> addChild (sp4, 0, 104); // balise balise 104
// Définir cinq minuteries, mettre à jour l'assistant
this-> scheduleUpdate ();
this-> schedule (schedule_selector (HelloWorld :: myupdate));
this-> schedule (schedule_selector (HelloWorld :: myupdate2), 1.0f);
this-> schedule (schedule_selector (HelloWorld :: myupdate3), 1.0f, 5, 3.0f);
this-> scheduleOnce (schedule_selector (HelloWorld :: myupdate4), 5.0f);
//
2. Écrivez le corps de la fonction de rafraîchissement correspondant à la minuterie
//
// scheduleUpdate
void HelloWorld :: update (float dt)
{
CCSprite * sp = (CCSprite *) this-> getChildByTag (100); // Récupère le sprite avec tag = 100
sp-> setPosition (sp-> getPosition () + ccp (1,0)); // Déplacer 1 par image
}
// calendrier (sélecteur_horaire)
void HelloWorld :: myupdate (float dt)
{
CCSprite * sp1 = (CCSprite *) this-> getChildByTag (101); // Récupère le sprite avec tag = 101
sp1-> setPosition (sp1-> getPosition () + ccp (1,0)); // Déplacer 1 par image
}
// programme (sélecteur_horaire, intervalle)
void HelloWorld :: myupdate2 (float dt)
{
CCSprite * sp2 = (CCSprite *) this-> getChildByTag (102); // Récupère le sprite avec tag = 102
sp2-> setPosition (sp2-> getPosition () + ccp (60,0)); // Déplacer 60 par seconde
}
// programme (sélecteur_horaire, intervalle, répétition, délai)
void HelloWorld :: myupdate3 (float dt)
{
CCSprite * sp3 = (CCSprite *) this-> getChildByTag (103); // Récupère le sprite avec tag = 103
sp3-> setPosition (sp3-> getPosition () + ccp (60,0)); // Déplacement de 60 par seconde
}
// scheduleOnce
void HelloWorld :: myupdate4 (float dt)
{
CCSprite * sp4 = (CCSprite *) this-> getChildByTag (104); // Récupère le sprite avec tag = 104
sp4-> setPosition (sp4-> getPosition () + ccp (100,0)); // déplacer 100
}
//
3. Résultats d'exécution
4. Analyse et résumé
(1) ScheduleUpdate () a le même effet que schedule (schedule_selector), sauf que schedule peut personnaliser le corps de la fonction d'actualisation, pas nécessairement update (). Le corps de la fonction de rafraîchissement de scheduleUpdate () ne peut être que update ().
(2) schedule (schedule_selector, interval): interval = 1.0 est défini, donc myupdate2 () est exécuté toutes les 1.0 secondes.
(3) schedule (schedule_selector, interval, repeat, delay): commencez à exécuter myupdate3 () après 3.0f secondes, puis répétez l'exécution 5 fois, puis arrêtez la mise à jour.
(4) scheduleOnce (schedule_selector): 5 secondes après le démarrage, myupdate4 () est exécuté une seule fois et la mise à jour est arrêtée.