Merge pull request Javi96#115 from Javi96/Lidiacon-patch-1

Terminado

UI/dialog.js

@@ -0,0 +1,15 @@
+Quintus.Dialog = function(Q) {
+    /**
+     * Clase que representa la ventana de diálogo.
+     */
+    Q.Sprite.extend('Dialog', {
+        init: function(p) {
+            this._super(p, {
+                asset: 'dialog_box.png',
+                type: Q.SPRITE_UI,
+                x: Q.width / 2,
+                y: Q.height - 80
+            });
+        }
+    });
+};

UI/heart.js

@@ -0,0 +1,39 @@
+Quintus.Heart = function(Q) {
+    /**
+     * Clase que representa las vidas que tiene Link.
+     * Se representan por corazones, cada uno con un num.
+     */
+    Q.Sprite.extend('Heart', {
+        init: function(p) {
+            this._super(p, {
+                sheet: 'heart',
+                sprite: 'heartAnim',
+                gravity: 0,
+                x: 20,
+                y: 20,
+                scale: 2,
+                type: Q.SPRITE_UI,
+                actualLives: 3
+            });
+            this.add('animation');
+
+            Q.state.on('change.lives', this, 'lives');
+        },
+
+        /**
+         * Si cambia el número de vidas, se anima el último corazón.
+         */
+        lives: function(lives) {
+            if (this.p.actualLives > lives) {
+                if (this.p.num === lives) {
+                    this.play('getHit');
+                }
+            }
+            this.p.actualLives = lives;
+        }
+    });
+
+    Q.animations('heartAnim', {
+        'getHit': { frames: [1, 2], rate: 1 / 4, loop: false },
+    });
+};

UI/hud.js

@@ -0,0 +1,18 @@
+Quintus.Hud = function(Q) {
+    /**
+     * Clase que representa los elementos de HUD,
+     * como son las rupias y la vida.
+     */
+    Q.scene('hud', function(stage) {
+        var hearts = [];
+        for (var i = 0; i < 3; i++) {
+            hearts[i] = new Q.Heart({ x: 20 + i * 20, num: i });
+            if (Q.state.get('maxLives') > Q.state.get('lives') && i >= Q.state.get('lives')) {
+                hearts[i].p.frame = 2;
+            }
+            stage.insert(hearts[i]);
+        }
+        stage.insert(new Q.RupeeCount());
+        stage.insert(new Q.Score());
+    }, { stage: 1 });
+};

UI/rupeecount.js

@@ -0,0 +1,42 @@
+Quintus.RupeeCount = function(Q) {
+    /**
+     * Clase que representa el icono de contador de rupias
+     */
+    Q.Sprite.extend('RupeeCount', {
+        init: function(p) {
+            this._super(p, {
+                asset: 'rupee_icon.png',
+                gravity: 0,
+                type: Q.SPRITE_UI,
+                x: Q.width - 100,
+                y: 20,
+                scale: 2
+            });
+        }
+    });
+
+    /**
+     * Contador de rupias como tal
+     */
+    Q.UI.Text.extend('Score', {
+        init: function(p) {
+            this._super(p, {
+                label: 'x ' + Q.state.get('score'),
+                x: Q.width - 50,
+                y: 10,
+                color: 'white',
+                size: 18
+            });
+
+            Q.state.on('change.score', this, 'score');
+        },
+
+        /**
+         * Si cambia el número de rupias, se activa
+         */
+        score: function(score) {
+            Q.audio.play('rupee_counter.mp3');
+            this.p.label = 'x ' + score;
+        }
+    });
+};

enemies/deadrock.js

@@ -0,0 +1,34 @@
+Quintus.Deadrock = function(Q) {
+
+    /**
+     * Creación de enemigo Deadrock con su movimiento
+     */
+
+    Q.Sprite.extend('Deadrock', {
+        init: function(p) {
+            this._super(p, {
+                sheet: 'deadrockWalk',
+                sprite: 'deadrockAnim',
+                hp: 1,
+                vx: 50,
+                direction: 'left',
+                score: 5
+            });
+            this.add('defaultEnemy, 2d, aiBounce');
+        },
+
+        step: function(dt) {
+            this.p.invicible -= dt;
+            this.p.direction = (this.p.vx > 0) ? 'right' : 'left';
+            this.play('walk_' + this.p.direction + '_foot');
+            if (Q.state.get(this.p.id_enemy)) {
+                this.destroy();
+            }
+        }
+    });
+
+    Q.animations('deadrockAnim', {
+        walk_left_foot: { frames: [0, 1], rate: 1 / 10, loop: true },
+        walk_right_foot: { frames: [0, 1], flip: 'x', rate: 1 / 10, loop: true }
+    });
+};

enemies/defaultenemy.js

@@ -0,0 +1,79 @@
+Quintus.LoadDefaultEnemy = function(Q) {
+
+    /**
+     * Componente defaultEnemy, necesario para todos los enemigos
+     */
+    Q.component('defaultEnemy', {
+        defaults: {
+            dead: false,
+            gravity: 0,
+            invicibleTime: 1,
+            invicible: 0,
+            score: 1
+        },
+
+        added: function() {
+            this.entity.p.type = Q.SPRITE_ENEMY;
+            Q._defaults(this.entity.p, this.defaults);
+            this.entity.add('animation');
+            this.entity.on('kicked', this, 'kicked');
+            this.entity.on('dead', this, 'dead');
+        },
+
+        /**
+         * Se activa cuando el enemigo es golpeado.
+         * Es invulnerable durante un tiempo y retrocede
+         */
+        kicked: function(enemy, direction) {
+            if (this.entity.p.invicible < 0) {
+                this.entity.p.invicible = this.entity.p.invicibleTime;
+                this.entity.p.hp--;
+                if(enemy=='ganonAnim'){
+                    this.stun(direction);
+                }
+                if (this.entity.p.hp == 0) {
+                    Q.audio.play('enemy_killed.mp3');
+                    this.entity.trigger('dead');
+                } else {
+                    Q.audio.play('enemy_hurt.mp3');
+                    this.entity.animate({ opacity: 0 }, 0.5);
+                    this.entity.animate({ opacity: 1 }, 0.5, { delay: 0.5 });
+                }
+            }
+        },
+
+        /**
+         * Se activa si el enemigo tiene 0 PV,
+         * inserta la animación de su muerte
+         */
+        dead: function() {
+            var obj = this.entity.stage.insert(new Q.EnemyKilled({ x: this.entity.p.x, y: this.entity.p.y }));
+            Q.state.inc('score', this.entity.p.score);
+            Q.state.set(this.entity.p.id_enemy, true);
+            if(this.entity.destroyEffect)
+                this.entity.destroyEffect();
+            this.entity.destroy();
+        }, 
+
+        /**
+         * Indica la dirección hacia la que debe retroceder el enemigo
+         * cuando es golpeado
+         */
+        stun: function(direction){
+            switch(direction){
+                case '_up':
+                    this.entity.animate({ y: this.entity.p.y-50});
+                    break;
+                case '_down':
+                    this.entity.animate({ y: this.entity.p.y+50});
+                    break;
+                case '_left':
+                    this.entity.animate({ x: this.entity.p.x-50 });
+                    break;
+                default:
+                    this.entity.animate({ x: this.entity.p.x+50});
+           }
+
+        }
+    });
+};

enemies/enemykilled.js

@@ -0,0 +1,28 @@
+Quintus.EnemyKilled = function(Q) {
+
+    /**
+     * Clase auxiliar que contiene
+     * la animación de un enemigo muerto
+     */
+
+    Q.Sprite.extend('EnemyKilled', {
+        init: function(p) {
+            this._super(p, {
+                sheet: 'enemyKilled',
+                sprite: 'enemyKilledAnim',
+            });
+            this.add('animation');
+            this.on('end', this, 'end');
+            this.play('play');
+        },
+        step: function(dt) {},
+
+        end: function() {
+            this.destroy();
+        }
+    });
+
+    Q.animations('enemyKilledAnim', {
+        play: { frames: [0, 1, 2, 3, 4, 5], rate: 1 / 10, loop: false, trigger: 'end' },
+    });
+};

enemies/fire.js

@@ -0,0 +1,49 @@
+Quintus.Fire = function(Q) {
+
+    /**
+     * Sprite que representa los ataques de fuego de Ganon
+     */
+    Q.Sprite.extend('fire', {
+        init: function(p) {
+            this._super(p, {
+                asset: "explosion.png",
+                collisionMask: Q.SPRITE_PLAYER | Q.SPRITE_WALL | Q.SPRITE_FIRE,
+                type: Q.SPRITE_FIRE,
+                gravity:0,
+                target: undefined,
+                vx: 0,
+                vy: 0,
+                lifeTime: 8,
+                delay:1,
+            })
+            this.add('2d, aiBounce');
+            this.p.target = (Q('Link').first()).p;
+        },
+
+        /**
+         * Se define el rebote
+         * y la desaparición de las bolas de fuego
+         */
+        step: function(dt) {
+            if(this.p.delay - dt > 0)
+                this.p.delay -= dt;
+            else{
+                if(this.p.vx == 0 && this.p.vy == 0){
+                    deltaX = this.p.target.x - this.p.x;
+                    deltaY = this.p.target.y - this.p.y;
+                    scale = Math.sqrt(Math.pow(deltaX, 2) + Math.pow(deltaY, 2));
+                    total = Math.abs(deltaX) + Math.abs(deltaY);
+                    this.p.vx = (deltaX / scale) * 75;
+                    this.p.vy = (deltaY / scale) * 75;
+                }else{
+                    this.p.lifeTime -=dt;
+                    if(this.p.lifeTime <= 0){
+                        this.destroy();
+                    }
+                }
+            }
+        },
+    });
+
+
+};