2 次代码提交 7b6e2fa9eb ... b4d177813a

作者 SHA1 备注 提交日期
  JoaoHL b4d177813a Adicionado comentários sobre as coisas 7 年之前
  JoaoHL 5228ace568 Adicionado comentários sobre as coisas 7 年之前
共有 6 个文件被更改,包括 282 次插入59 次删除
  1. 14 21
      Classes/GameScene.cpp
  2. 161 13
      Classes/GameScene.h
  3. 8 8
      Classes/GameScene/BlocksLayer.cpp
  4. 50 9
      Classes/GameScene/BlocksLayer.h
  5. 40 0
      Classes/GameScene/GameScene.h
  6. 9 8
      Classes/params.h

+ 14 - 21
Classes/GameScene.cpp

@@ -1,10 +1,11 @@
-//
-//  GameScene.cpp
-//  RedCore2
-//
-//  Created by Gabriel Capella on 31/05/17.
-//
-//
+/********************************************************************
+ *  Nomes: Gabriel Capella                       Números USP: 8962078 
+ *         João Herique Luciano                               8535957
+ * 
+ *  Tarefa:    RedCore - EP2 MAC0463
+ *  Arquivo:   GameScene.cpp
+ *  Descrição: Implementação do cenário e do mecanismo de jogo
+ ********************************************************************/
 
 #include "GameScene.h"
 #include "SimpleAudioEngine.h"
@@ -26,7 +27,7 @@ Scene* GameScene::createScene(int level) {
     GameScene* layer = GameScene::create();
     scene->addChild(layer);
     
-    // the edge of the screen
+    // parede da tela
     auto body = PhysicsBody::createEdgeBox(visibleSize, PhysicsMaterial(0.0f, 1.0f, 0.0f));
     auto edgeNode = Node::create();
     edgeNode->setPosition(Point(visibleSize.width/2,visibleSize.height/2));
@@ -34,7 +35,7 @@ Scene* GameScene::createScene(int level) {
     edgeNode->setPhysicsBody(body);
     scene->addChild(edgeNode);
     
-    // bottom edge
+    // parede de baixo
     auto bottom_body = PhysicsBody::createEdgeBox(Size(visibleSize.width, 0));
     auto bottomNode = Node::create();
     bottomNode->setPosition(Point(visibleSize.width/2, 0));
@@ -70,9 +71,8 @@ Scene* GameScene::createScene(int level) {
     return scene;
 }
 
-// on "init" you need to initialize your instance
 bool GameScene::init() {
-    //////////////////////////////
+    
     // 1. super init first
     if ( !Layer::init() ) {
         return false;
@@ -93,7 +93,7 @@ bool GameScene::init() {
     height = visibleSize.height;
     Vec2 origin = Director::getInstance()->getVisibleOrigin();
     
-    // Adiona o fundo
+    // Adiciona o fundo
     auto bg = LayerColor::create(COLOR_back);
     addChild(bg);
     
@@ -226,7 +226,7 @@ void GameScene::caseBallCore (Node *core, Node *ball) {
         addChild(menu, 30);
     });
     
-    // create a sequence with the actions and callbacks
+    // cria uma sequencia com as ações e callbacks
     auto seq = Sequence::create(scaleBy, callbackRotate, nullptr);
     core->runAction(seq);
     removeBallsAndPowersUP();
@@ -256,7 +256,6 @@ void GameScene::setLevel(int level) {
     addChild(text);
 }
 
-// Power-up: salva o nível atual
 void GameScene::saveLevel() {
     if (over) return;
     
@@ -266,7 +265,6 @@ void GameScene::saveLevel() {
     delayCallback(CC_CALLBACK_0(GameScene::saveLevel, this));
 }
 
-// Power-up: deixa 3 bolas na tela ao invés de 1
 void GameScene::tripleBallsAppearance() {
     if (over) return;
     double delta = (time(NULL)-last_touch);
@@ -296,11 +294,7 @@ void GameScene::paddleBallAppearance() {
     delayCallback(CC_CALLBACK_0(GameScene::paddleBallAppearance, this));
 }
 
-/* Power-up/down: 50% de chance de dobrar o tamanho da paddle,
- e 50% de chance de diminuir seu tamanho pela metade.
- Para não ficar muito fácil/difícil, impusemos tamanho mínimo/máximo da paddle.
- */
-void GameScene::caseRaqueteBall(Node *powerup_ball) {
+void GameScene::casePaddleBall(Node *powerup_ball) {
     if (!over) {
         if (rand_0_1() < 0.5) {
             alert(MSG_DOUBLE_PADDLE);
@@ -322,7 +316,6 @@ void GameScene::alert(std::string text) {
     }
 }
 
-// Power-up: deixa 3 bolas na tela ao invés de 1
 void GameScene::superBallAppearance() {
     if (over) return;
     

+ 161 - 13
Classes/GameScene.h

@@ -1,10 +1,11 @@
-//
-//  GameScene.h
-//  RedCore2
-//
-//  Created by Gabriel Capella on 31/05/17.
-//
-//
+/********************************************************************
+ *  Nomes: Gabriel Capella                       Números USP: 8962078 
+ *         João Herique Luciano                               8535957
+ * 
+ *  Tarefa:    RedCore - EP2 MAC0463
+ *  Arquivo:   GameScene.h
+ *  Descrição: Classe do cenário e do mecanismo de jogo
+ ********************************************************************/
 
 #ifndef GameScene_h
 #define GameScene_h
@@ -14,36 +15,183 @@
 
 class GameScene : public cocos2d::Layer {
     public:
+        /**
+         * @brief Cria a cena do jogo
+         * 
+         * @param level - nível atual do jogo
+         * @return - Ponteiro para objeto da cena do jogo
+         */
         static cocos2d::Scene* createScene(int level);
+
+        /**
+         * @brief Inicializa essa classe
+         *
+         */
         virtual bool init();
+
+        /**
+         * @brief Processa o contato entre duas formas no jogo
+         * 
+         * @param contact objeto representando o contato entre duas formas no cocos2d
+         * @return Indicador de que houve colisão
+         */
         bool onContactBegin(cocos2d::PhysicsContact& contact);
+
+        /**
+         * @brief Macro do cocos2d-x para criar um método create() para certa classe
+         * 
+         * @param  Nome da classe cujo método create() será criado
+         */
         CREATE_FUNC(GameScene);
+
+        /**
+         * @brief configura o jogo para um certo nível
+         * 
+         * @param level nível do jogo
+         */
         void setLevel(int level);
+
+        /**
+         * @brief Mostra um(a) alerta/mensagem na tela do jogo
+         * 
+         * @param text string contendo a mensagem a ser mostrada
+         */
         void alert(std::string text); // Mostra alerta
     private:
+
+        /**
+         * @brief Caso de colisão entre a bola e a parte inferior da tela
+         * 
+         * @param ball Nó representando a bola que colidiu com a parte inferior da tela
+         */
         void caseBallCollision (cocos2d::Node *ball);
+
+        /**
+         * @brief Caso de colisão entre a bola e o núcleo
+         * 
+         * @param core Nó da árvore que representa o núcleo
+         * @param ball Nó da árvore que representa a bola
+         */
         void caseBallCore (cocos2d::Node *core, cocos2d::Node *ball);
+
+        /**
+         * @brief Caso onde o usuário pegou o power-up de salvar o nível
+         * 
+         * @param powerup_ball Nó que representa o power-up
+         */
         void caseSaveLevel(Node *powerup_ball);
+
+        /**
+         * @brief Substitui a cena atual pela cena do próximo nível
+         * 
+         */
         void nextLevel();
+
+        /**
+         * @brief Salva o nível atual
+         */
         void saveLevel();
+
+        /**
+         * @brief Define a probabilidade de aparição e a geração do power
+         *        up das bolas triplas
+         */
         void tripleBallsAppearance();
+
+        /**
+         * @brief Caso onde o usuário pegou o power-up de bolas triplas
+         * 
+         * @param powerup_ball Nó que representa o power-up
+         */
         void caseTripleBalls(Node *powerup_ball);
+
+        /**
+         * @brief Define a probabilidade de aparição e a geração
+         *        do power up de aumento/diminução da pá
+         */
         void paddleBallAppearance();
-        void caseRaqueteBall(Node *powerup_ball);
+
+        /**
+         * @brief Caso onde o usuário pegou o power-up de
+         *        aumento/diminuição da pá
+         * 
+         * @param powerup_ball Nó que representa o power-up
+         */
+        void casePaddleBall(Node *powerup_ball);
+
+        /**
+         * @brief Define a probabilidade de aparição e a geração
+         *        do power up da super-bola
+         */ 
         void superBallAppearance();
+
+        /**
+         * @brief Caso onde o usuário pegou o power-up da super-bola
+         * 
+         * @param powerup_ball Nó que representa o power-up
+         */
         void caseSuperBall(Node *powerup_ball);
+
+        /**
+         * @brief Adiciona e joga uma nova bola na cena
+         */
         void addAndThrowBall();
+
+        /**
+         * @brief Remove as bolas e os power-ups que estão na tela
+         */
         void removeBallsAndPowersUP();
+
+        /**
+         * @brief Cria a bolinha que representa o power-up
+         * 
+         * @param color Cor da bolinha
+         * @param tag identificação da bolinha (usada no tratamento de colisões)
+         */
         void createPowerUpBody(cocos2d::Color4B color, int tag);
+
+        /**
+         * @brief Cria um delay com callback que será usado na aparição dos
+         *        power-ups
+         * 
+         * @param func função a ser chamada no callback
+         */
         void delayCallback(const std::function<void ()> &func);
+
+        /**
+         * Nível atual
+         */
         int level;
-        bool over; // salva se o jogo acabou!
+
+        /**
+         * Indica se o jogo já acabou
+         */
+        bool over;
+
+        /**
+         * Ponteiro para a pá do jogo
+         */
         Paddle * paddle;
-        cocos2d::Node* balls; // Bolas
-        cocos2d::Node* power_ups; // Bolas
+
+        /**
+         * Lista de bolas na cena
+         */
+        cocos2d::Node* balls;
+
+        /**
+         * Lista de power-ups na cena
+         */
+        cocos2d::Node* power_ups;
+
+        /**
+         * Tamanho da tela
+         */
         double height, width; // tamanho do quadro
-        unsigned long int last_touch; // ultima vez que a bola colidiu com algo
-};
 
+        /**
+         * Última vez que a bola colidiu no jogo
+         */
+        unsigned long int last_touch;
+};
 
 #endif /* GameScene_h */

+ 8 - 8
Classes/GameScene/BlocksLayer.cpp

@@ -1,7 +1,11 @@
-//
-//  BlocksLayer.cpp
-//  RedCore
-//
+/********************************************************************
+ *  Nomes: Gabriel Capella                       Números USP: 8962078 
+ *         João Herique Luciano                               8535957
+ * 
+ *  Tarefa:    RedCore - EP2 MAC0463
+ *  Arquivo:   BlocksLayer.cpp
+ *  Descrição: Implementação da classe de construção dos blocos
+ ********************************************************************/
 
 #include "BlocksLayer.h"
 #include "../params.h"
@@ -33,7 +37,6 @@ void BlocksLayer::setLevel(int level) {
     CCLOG(">> %f", p_indus);
     this->setPosition(center);
     
-    // aumentar aqui
     for (int i = circles_n - 1; i >= 0; i--) {
         auto circle = createCircle(size, i, 10, p_indus);
         this->addChild(circle, 9);
@@ -46,10 +49,8 @@ void BlocksLayer::setLevel(int level) {
     physicsBody->setDynamic(false);
     physicsBody->setGroup(-1);
     physicsBody->setContactTestBitmask(0xFFFFFFFF);
-    //physicsBody->setPositionOffset(center);
     
     auto core = DrawNode::create();
-    //core->drawCircle(center, CORE_RADIUS, M_PI, 30, false, Color4F(COLOR_blue));
     core->drawDot(Vec2(), CORE_RADIUS, COLOR_red);
     core->addComponent(physicsBody);
     core->setTag(CORE_TAG);
@@ -73,7 +74,6 @@ Node* BlocksLayer::createCircle (double size, int number, int number_of_segments
         points[i] = 2.0*M_PI/number_of_segments * i;
         points[i] += rand_minus1_1()*0.9*M_PI/number_of_segments;
     }
-    //std::sort(points, points+number_of_segments);
     points[number_of_segments] = points[0] + 2*M_PI;
     
     for (int i = 0; i < number_of_segments; i++) {

+ 50 - 9
Classes/GameScene/BlocksLayer.h

@@ -1,7 +1,11 @@
-//
-//  BlocksLayer.h
-//  RedCore
-//
+/********************************************************************
+ *  Nomes: Gabriel Capella                       Números USP: 8962078 
+ *         João Herique Luciano                               8535957
+ * 
+ *  Tarefa:    RedCore - EP2 MAC0463
+ *  Arquivo:   BlocksLayer.h
+ *  Descrição: Classe de construção dos blocos - header
+ ********************************************************************/
 
 #ifndef BlocksLayer_h
 #define BlocksLayer_h
@@ -10,13 +14,50 @@
 
 class BlocksLayer : public cocos2d::Node {
     public:
-    virtual bool init();
-    void setLevel(int level);
-    CREATE_FUNC(BlocksLayer);
+
+    	/**
+    	 * @brief Inicializa os blocos da fase
+    	 */
+	    virtual bool init();
+
+	    /**
+	     * @brief Configura os blocos de acordo com nível da fase
+	     * 
+	     * @param level - indica o nível da fase a ser criada
+	     */
+	    void setLevel(int level);
+
+	    /**
+	     * @brief Macro do cocos2d-x para criar o método create(), que
+	     *        cria um objeto dessa classe
+	     * 
+	     * @param  Nome da classe à qual o objeto pertence
+	     */
+	    CREATE_FUNC(BlocksLayer);
 
     private:
-    Node* createCircle (double size, int number, int number_of_segments, double p);
-    Node* createSegment (double r_internal, double r_externa, double begin, double end, bool especial);
+    	/**
+    	 * @brief Cria uma camada de blocos ao redor do núcleo
+    	 * 
+    	 * @param size - espessura
+    	 * @param number - número da camada
+    	 * @param number_of_segments - número de segmentos (blocos) da camada
+    	 * @param p - probabilidade de cada segmento ser indestrutível 
+    	 * @return - nó da camada de blocos
+    	 */
+		Node* createCircle (double size, int number, int number_of_segments, double p);
+
+		/**
+		 * @brief - cria um bloco (segmento da camada)
+		 * 
+		 * @param r_internal - raio do círculo que delimita a parte mais interna da camada
+		 * @param r_externa - raio do círculo que delimita a parte mais externa da camada
+		 * @param begin - onde começa lateralmente o bloco
+		 * @param end - onde termina lateralmente o bloco
+		 * @param especial - indica se o bloco em questão é indestrutível ou não
+		 * @return [description]
+		 */
+	    Node* createSegment (double r_internal, double r_externa, double begin, double end, bool especial);
 };
 
 

+ 40 - 0
Classes/GameScene/GameScene.h

@@ -0,0 +1,40 @@
+//
+//  GameScene.h
+//  RedCore
+//
+
+#ifndef GameScene_h
+#define GameScene_h
+
+#include "cocos2d.h"
+
+class GameScene : public cocos2d::Layer {
+    public:
+        static cocos2d::Scene* createScene(int level);
+        virtual bool init();
+        bool onContactBegin(cocos2d::PhysicsContact& contact);
+        CREATE_FUNC(GameScene);
+        void setLevel(int level);
+        void alert(std::string text); // Mostra alerta
+    private:
+        void caseBallCollision (cocos2d::Node *ball);
+        void caseBallCore (cocos2d::Node *core, cocos2d::Node *ball);
+        void caseSaveLevel(Node *powerup_ball);
+        void NextLevel(cocos2d::Ref *pSender);
+        void saveLevel();
+        void tripleBallsAppearance();
+        void caseTripleBalls(Node *powerup_ball);
+        void paddleBallAppearance();
+        void casePaddleBall(Node *powerup_ball);
+        void addAndThrowBall();
+        int level;
+        bool over; // salva se o jogo acabou!
+        cocos2d::DrawNode * paddle;
+        int paddle_size; // tamanho atual da raquete
+        cocos2d::Node* balls; // Bolas
+        double height, width; // tamanho do quadro
+        int last_touch; // ultima vez que a bola colidiu com algo
+};
+
+
+#endif /* GameScene_h */

+ 9 - 8
Classes/params.h

@@ -1,10 +1,11 @@
-//
-//  params.h
-//  RedCore2
-//
-//  Created by Gabriel Capella on 31/05/17.
-//
-//
+/********************************************************************
+ *  Nomes: Gabriel Capella                       Números USP: 8962078 
+ *         João Herique Luciano                               8535957
+ * 
+ *  Tarefa:    RedCore - EP2 MAC0463
+ *  Arquivo:   params.h
+ *  Descrição: Definições de parâmetros usados no jogo
+ ********************************************************************/
 
 #ifndef params_h
 #define params_h
@@ -14,7 +15,7 @@
 #define THROW_ANG 20 // in degrees
 #define INITIAL_SPEED 500
 
-// CORE
+// TAMANHO DO NUCLEO
 #define CORE_RADIUS 50
 
 // PADDLE