Browse Source

Merge branch 'master' of ssh://git.capella.pro:10022/capella/RedCore

capellaresumo 6 years ago
parent
commit
666efc3672
8 changed files with 359 additions and 73 deletions
  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
  7. 57 14
      README.md
  8. 20 0
      manual.txt

+ 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

+ 57 - 14
README.md

@@ -1,25 +1,68 @@
-Não roda no emuladador!
+/********************************************************************
+ *  Nomes: Gabriel Capella                       Números USP: 8962078 
+ *         João Herique Luciano                               8535957
+ * 
+ *  Tarefa:    RedCore - EP2 MAC0463
+ *  Arquivo:   README.md
+ *  Descrição: Pequeno relatório sobre o EP2
+ ********************************************************************/
+									REDCORE
 
-Antes de montar o arquivo você deve configurar o arquivo `proj.android-studio/local.properties`.
+O jogo desenvolvido nesse projeto foi um estilo brick-break onde o objetivo é
+avançar de fases atingindo o núcleo vermelho dentro das camadas de blocos.
+Os blocos em questão podem ser destrúidos ao serem atingidos pela(s) bola(s)
+em jogo.
 
-Para montar o APK do jogo:
+Satisfazendo alguns requisitos do trabalho, foram implementadas as seguin-
+tes funcionalidades:
+- Power ups-downs: aumento/diminuição da pá; bolas múltiplas (até 3);
+				   salvar o nível do jogo; super-bola, capaz de destruir
+				   qualquer tipo de bloco
 
-```
-./build
-```
+- Fases aleatórias: as fases são geradas aleatoriamente, no sentido de
+					variação do tamanho, cor e velocidade de rotação dos
+					blocos
+
+- Blocos móveis: os blocos se movem ao redor do núcleo
+
+- Mais de um tipo de bloco: existem dois tipos de blocos (normais e 
+							indestrutiveis)
+
+Alguns detalhes que devem ser mencionados sobre a implementação:
 
-# Manual
+- Os power ups colidem com a bola, podendo ser jogados para fora do mapa
+  (isso foi proposital para aumentar a dificuldade)
+- O nível salvo pelo jogo reduz em 1 para cada 12 horas sem jogar
+  (queremos que o jogador jogue sempre que possível)
+- O jogo não tem pausa (propositalmente, também), pois o objetivo
+  é conquistar o máximo de níveis possíveis numa jogatina
 
-## Power UPs
-### SuperBola
-ë o power up laranja o responsável por esse efeito. Qunado o usuário possui uma superbola, a bola fica laranja e tem capacidade de destruir os blocos indestritíveis (somente um toque).
+Sobre os power-ups:
+- Aumento/diminuição da pá (power-up azul): tem 50% de chance de aumentar
+  ou de diminuir a pá (diminuir pela metade e aumentar para o dobro do tamanho).
+  A pá volta ao seu tamanho normal depois de um tempo.
+- Bolas múltiplas (power-up rosa): aumenta o número de bolas no jogo para 3.
+- Salvamento do nível (power-up verde): salva o nível atual do jogo
+- Super-bola (power-up): a bola pode destruir tanto os blocos normais
+  quanto o bloco indestrutível. Ela volta ao normal depois de destruir
+  um bloco indestrutível.
 
 
-Esse script vai fazer o download do cocos2d-x (por volta de 350mb).
+Para o desenvolvimento do jogo, foi utilizada o framework cocos2d-x,
+em C++, e o DoxyDoc (para Sublime Text) para a documentação do código.
+O jogo foi desenvolvido para Android, e testado em um celular Motorola
+G4 com Android 7.0. O cocos2d foi utilizado devido à sua simplicidade
+de programação e entendimento da ferramenta.
 
-Quando uma raquete muda de tamanho, ela volta ao seu tamho original depois de certo tempo.
 
-Politica de redimencionamento.
+Algumas observações:
 
-No border policy will scale proportionally the container so that it fills up the entire frame. In this case, if the width/height ratio of the frame doesn't equal to your designed ratio, some area of your game will be cut off. In the meantime, under no border policy, cc.visibleRect represent the viewport of canvas in the game world, and it can be smaller than cc.winSize.
+- NÃO RODA NO EMULADOR!
 
+- Antes de montar o arquivo você deve configurar o arquivo `proj.android-studio/local.properties`.
+
+- Para montar o APK do jogo:
+
+```
+./build
+```

+ 20 - 0
manual.txt

@@ -0,0 +1,20 @@
+# Manual
+
+O jogo tem por objetivo avançar pelas fases, quebrando os blocos e
+atingindo o núcleo vermelho no topo da tela. Para tanto, serão usadas
+uma bolinha, que colidirá com os blocos, e uma pá, cuja movimentação
+será controlada com o toque do usuário (a pá se move para onde o
+usuário tocou pela última vez). Além disso, o usuário poderá contar com
+os seguintes power-ups:
+- Aumento/diminuição da pá (power-up azul): tem 50% de chance de aumentar
+  ou de diminuir a pá (diminuir pela metade e aumentar para o dobro do tamanho).
+  A pá volta ao seu tamanho normal depois de um tempo.
+- Bolas múltiplas (power-up rosa): aumenta o número de bolas no jogo para 3.
+- Salvamento do nível (power-up verde): salva o nível atual do jogo
+- Super-bola (power-up): a bola pode destruir tanto os blocos normais
+  quanto o bloco indestrutível. Ela volta ao normal depois de destruir
+  um bloco indestrutível.
+
+Ao atingir o núcleo com a bolinha, o usuário passará para a pŕoxima fase,
+mas caso a única bolinha em jogo colida com a parte inferior da tela, o
+jogo acabará.