En la lección anterior, implementamos la adición de un botón de habilidad con un efecto de enfriamiento para enseñar a tus héroes a agregar ults deslumbrantes. Si planeas tener otras habilidades, solo agrégalas una por una, así no diré más. Esta lección trata sobre cómo agregar un botón en la esquina superior derecha de la capa del juego para implementar la función de pausa del juego.
Entorno de desarrollo
Win64: vs2010
Cocos2d-x v3.4Final
TexturePackerGUI
MapaEditar
Antes de comenzar, explique el método de implementación:
Cuando el juego está en pausa, los botones a continuación no deben tocarse. De lo contrario, habrá varios errores incontrolables, como animaciones que no se mueven, y los personajes pueden recurrir a otras cosas extrañas.
Entonces, primero agregue una capa protectora y luego agregue nuestro botón arriba.
Código
otro
BarreraCapa
.h
#ifndef _BARRIER_LAYER_H_
#define _BARRIER_LAYER_H_
#include "cocos2d.h"
USING_NS_CC;
clase BarrierLayer: capa pública
{
público:
BarrierLayer ();
~ Capa de barrera ();
bool init ();
CREATE_FUNC (BarrierLayer);
};
#terminara si
Este .h no tiene nada que decir.
.cpp
#include "BarrierLayer.h"
BarrierLayer :: BarrierLayer ()
{
}
BarrierLayer :: ~ BarrierLayer ()
{
}
bool BarrierLayer :: init ()
{
si (! Layer :: init ())
falso retorno;
// Agrega una capa semi-gris
LayerColor * backLayerColor = LayerColor :: crear (Color4B (25, 25, 25, 125));
this-> addChild (backLayerColor);
// Agregar bloque táctil hacia abajo
devolución de llamada automática = [] (Toque *, Evento *)
{
devuelve verdadero;
};
oyente automático = EventListenerTouchOneByOne :: create ();
oyente-> onTouchBegan = devolución de llamada;
oyente-> setSwallowTouches (verdadero);
_eventDispatcher-> addEventListenerWithSceneGraphPriority (oyente, esto);
}
Primero, se crea una capa translúcida y luego se agrega un monitor Siempre que el ZOerder esté configurado al agregar, la función de monitor de protección que necesitamos se puede realizar.
En mi opinión, esta es la mejor manera de entenderla e implementarla. De hecho, también se puede lograr cambiando el orden de escucha de los botones de la capa original. Pero es demasiado problema.
El craqueo por fuerza bruta más tonto es también un método de craqueo universal.
Luego crea la capa de pausa real que necesitamos.
GamePause
.h
Básicamente lo mismo que el anterior, simplemente crea una capa. Entonces no hay necesidad de volver a analizarlo, ¿verdad?
.cpp
#include "GamePause.h"
#include "GameScene.h"
#include "BarrierLayer.h"
#include "GameStartScene.h"
GamePause :: GamePause ()
{
}
GamePause :: ~ GamePause ()
{
}
bool GamePause :: init ()
{
si (! Layer :: init ())
falso retorno;
// Abajo está nuestro botón
Tamaño WinSize = Director :: getInstance () -> getWinSize ();
Vec2 CenterPoint = Vec2 (WinSize.width / 2, WinSize.height / 2);
auto continuebutton = Button :: create ("buttonclick.png");
continuebutton-> setTitleText ("Continuar");
continuebutton-> addTouchEventListener ([=] (Ref * pSender, Widget :: TouchEventType type) {
interruptor (tipo)
{
case cocos2d :: ui :: Widget :: TouchEventType :: ENDED:
{
getParent () -> removeFromParent ();
Director :: getInstance () -> resume ();
}
descanso;
}
});
reiniciar automático botón = Botón :: crear ("buttonclick.png");
reiniciarbutton-> setTitleText ("Reiniciar");
reiniciarbutton-> addTouchEventListener ([=] (Ref * pSender, Widget :: TouchEventType tipo) {
interruptor (tipo)
{
case cocos2d :: ui :: Widget :: TouchEventType :: ENDED:
{
// Detuve todas las escenas antes, e incluso si creas una nueva escena sin responder, sigue siendo una pausa
Director :: getInstance () -> resume ();
Director :: getInstance () -> replaceScene (TransitionCrossFade :: create (0.5f, GameScene :: createScene ()));
}
descanso;
}
});
auto titlebutton = Button :: create ("buttonclick.png");
titlebutton-> setTitleText ("ToTitle");
titlebutton-> addTouchEventListener ([=] (Ref * pSender, Widget :: TouchEventType type) {
interruptor (tipo)
{
case cocos2d :: ui :: Widget :: TouchEventType :: ENDED:
{
Director :: getInstance () -> resume ();
// Director :: getInstance () -> replaceScene (GameStartScene :: createScene ());
}
descanso;
}
});
continuebutton-> setPosition (Vec2 (0,50) + CenterPoint);
reiniciarbutton-> setPosition (CenterPoint);
titlebutton-> setPosition (Vec2 (0, -50) + CenterPoint);
addChild (continuar botón);
addChild (botón de reinicio);
addChild (botón de título);
devuelve verdadero;
}
Cabe señalar en cpp: utilicé el control de la interfaz de usuario de Cocos Studio, que es más rápido que la creación original de un menú, y el botón usa 9Sprite, con su propia animación de estiramiento y cambio, y asegurándome de que la imagen no se distorsione (es práctico Sea perezoso, escriba mucho código menos), se debe prestar atención a la inclusión de código, también incluí el siguiente artículo y lo borré yo mismo.
El siguiente es también un método de monitoreo de botones, pero la función de devolución de llamada se escribe directamente detrás
continuebutton-> addTouchEventListener ([=] (Ref * pSender, Widget :: TouchEventType type) {
interruptor (tipo)
{
case cocos2d :: ui :: Widget :: TouchEventType :: ENDED:
{
getParent () -> removeFromParent ();
Director :: getInstance () -> resume ();
}
descanso;
}
});
Cabe señalar que aquí llamo removeFromParent del padre Es necesario combinar lo siguiente para usar.
Simplemente use removeFromParent directamente, tenga cuidado o todo el juego desaparecerá.
Los métodos que deben utilizarse aquí son:
Director :: getInstance () -> pause () // Pausar la escena
Director :: getInstance () -> replaceScene () // Crea una nueva escena para reemplazar la original
Director :: getInstance () -> resume (); // Reanudar escena
Si no hay currículum ..... Si estás interesado, puedes probar la situación.
PopupLayer
Esta es una capa emergente.
Aquí puede escribir algunos efectos de animación para mostrar una determinada capa emergente.
Porque lo anterior usa Layer en lugar de Scene para implementar la devolución de llamada de pausa (¿Por qué a otros tutoriales les gusta empujar una Escena? La recarga no es lenta).
Entonces podemos escribir animaciones emergentes de acuerdo con nuestras necesidades.
.h
#ifndef _POPUP_LAYER_H_
#define _POPUP_LAYER_H_
#include "cocos2d.h"
#include "BarrierLayer.h"
USING_NS_CC;
class PopupLayer: capa pública
{
público:
PopupLayer ();
~ PopupLayer ();
bool init (Capa * targetLayer, tipo int);
PopupLayer estático * create (Layer * targetLayer, tipo int const);
PopupLayer estático * create (Layer * targetLayer)
{return PopupLayer :: create (targetLayer, 0);};
Acción * getActionWithNum (int num);
};
#terminara si
Debe ingresar a la capa del objeto emergente, por lo que no puede usar la macro CREATE_FUNC.
.cpp
#include "PopupLayer.h"
PopupLayer :: PopupLayer ()
{
}
PopupLayer :: ~ PopupLayer ()
{
}
PopupLayer * PopupLayer :: create (Layer * targetLayer, tipo int const)
{
PopupLayer * popupLayer = new PopupLayer ();
if (popupLayer && popupLayer-> init (targetLayer, tipo))
{
popupLayer-> autorelease ();
return popupLayer;
}
más
{
CC_SAFE_DELETE (popupLayer);
return nullptr;
}
}
bool PopupLayer :: init (Layer * targetLayer, tipo int const)
{
si (! Layer :: init ())
falso retorno;
addChild (BarrierLayer :: create (), 0);
targetLayer-> setTag (1);
addChild (targetLayer, 1);
ventana emergente automática = getChildByTag (1);
//popup->setScale(0.9f);
popup-> runAction (getActionWithNum (tipo));
devuelve verdadero;
}
// La siguiente es la animación de la devolución de llamada, creada por el número de serie, de todos modos, solo unos pocos se mueven desde la ventana y se escriben una animación de jitter
// El valor predeterminado es la animación de jitter, que es 0
Acción * PopupLayer :: getActionWithNum (int num)
{
Tamaño WinSize = Director :: getInstance () -> getWinSize ();
interruptor (num)
{
caso 1:
{
auto act1 = MoveTo :: create (0.0f, Vec2 (0, WinSize.height));
auto act2 = MoveTo :: create (0.5f, Vec2 :: CERO);
return Sequence :: createWithTwoActions (act1, act2);
}
caso 2:
{
auto act1 = MoveTo :: create (0.0f, Vec2 (WinSize.width, 0));
auto act2 = MoveTo :: create (0.5f, Vec2 :: CERO);
return Sequence :: createWithTwoActions (act1, act2);
}
caso 3:
{
auto act1 = MoveTo :: create (0.0f, Vec2 (0, -WinSize.height));
auto act2 = MoveTo :: create (0.5f, Vec2 :: CERO);
return Sequence :: createWithTwoActions (act1, act2);
}
caso 4:
{
auto act1 = MoveTo :: create (0.0f, Vec2 (WinSize.width, 0));
auto act2 = MoveTo :: create (0.5f, Vec2 :: CERO);
return Sequence :: createWithTwoActions (act1, act2);
}
defecto:
{
auto scaleTo = ScaleTo :: crear (0.15f, 1.25f);
auto scaleTo2 = ScaleTo :: crear (0.1f, 0.8f);
return Sequence :: createWithTwoActions (scaleTo, scaleTo2);
}
}
}
En init,
Agrega una capa protectora
Agregue la capa de objeto que necesita ser expulsada
Deje que la capa del objeto ejecute la animación, el valor predeterminado es 0, que es jitter
Por supuesto, también puede crear una animación cuando desee eliminar. No hablaré de eso aquí.
Operador
operterLayer
.cpp
Ponga un botón en nuestra capa de control init para implementar la devolución de llamada de la capa emergente.
No lo olvides
#include "ui / CocosGUI.h"
#include "GamePause.h"
usando el espacio de nombres ui;
auto pause = Button :: create ("pause.png");
pause-> setPosition (Vec2 (WinSize.width- pause-> getContentSize (). width / 2, WinSize.height-pause-> getContentSize (). height / 2));
pause-> addTouchEventListener ([=] (Ref * pSender, Widget :: TouchEventType tipo)
{
interruptor (tipo)
{
case cocos2d :: ui :: Widget :: TouchEventType :: ENDED:
{
addChild (PopupLayer :: create (GamePause :: create ()));
Director :: getInstance () -> pause ();
}
descanso;
}
});
addChild (pausa);
efecto
Conclusión
El efecto de este artículo es agregar un botón para pausar y reiniciar el juego. El contenido adicional es agregar una capa protectora para evitar la penetración táctil y una animación emergente.
Siguiente artículo, crea la pantalla de inicio del juego. Después de todo, es imposible iniciar el juego directamente después de abrirlo, ¿verdad?