jaildesigner-jailgames/super_pang_clone
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

Compare commits

base: jaildesigner-jailgames:b4e76a4c7d34b320a032b3899fed743687ab4b55
Branches Tags
jaildesigner-jailgames:master
jaildesigner-jailgames:v1.0
...
compare: jaildesigner-jailgames:master
Branches Tags
jaildesigner-jailgames:master
jaildesigner-jailgames:v1.0

12 Commits
b4e76a4c7d ... master

Author SHA1 Message Date
Sergio
25de02a218 Añadido coffee_crisis_pre_git-7z 2023-05-14 19:26:48 +02:00
Sergio Valor
3a3182fc74 Eliminado sdl_mixer. Ya va con jail_audio 2022-10-21 18:01:33 +02:00
Sergio Valor
5098ed1638 Intentando hacer que suene jail_audio 2022-10-21 17:52:50 +02:00
Sergio Valor Martínez
f63ff07397 Actualizado Makefile 2022-10-21 16:49:00 +02:00
Sergio Valor Martínez
58f9841f71 Eliminado sdl_mixer 2022-10-21 16:48:21 +02:00
Sergio Valor Martínez
fd1fc0b582 Actualizado Makefile 2022-10-21 16:19:00 +02:00
Sergio Valor
770b06f2da Eliminado SDL_image 2022-10-21 14:02:16 +02:00
Sergio Valor
33ad51e1c2 Deshaciendose de sdl_image y sdl_mixer 2022-10-21 10:08:29 +02:00
Sergio Valor
0a16c1cd0e Actualizado .gitignore 2022-10-21 07:28:27 +02:00
Sergio
e8406c87b0 Eliminar 'super_pang_clone_linux' 2022-10-21 07:27:52 +02:00
Sergio Valor
ca5adf9433 Ya compila y no se cuelga 2022-10-20 18:31:53 +02:00
Sergio Valor
e753f6fbdb Actualizado .gitignore 2022-10-20 18:28:36 +02:00
33 changed files with 17681 additions and 4066 deletions
Expand all files Collapse all files

9
.gitignore vendored
View File

@@ -1,4 +1,5 @@
.DS_store
.vscode
super_pang_clone
bin
.DS_store
.vscode
super_pang_clone*
bin/*
info.plist*

24
Makefile
View File

@@ -1,15 +1,11 @@
executable = super_pang_clone
source = source/*.cpp
windows:
@echo off
if not exist bin\ (mkdir bin)
g++ $(source) -std=c++11 -Wall -O2 -lmingw32 -lSDL2main -lSDL2 -lSDL2_image -lSDL2_mixer -ffunction-sections -fdata-sections -Wl,--gc-sections -static-libstdc++ -Wl,-subsystem,windows -o $(executable).exe
strip -s -R .comment -R .gnu.version $(executable).exe --strip-unneeded
macos:
mkdir -p bin
g++ $(source) -std=c++11 -Wall -O2 -lSDL2 -lSDL2_image -lSDL2_mixer -ffunction-sections -fdata-sections -o $(executable)_macos
linux:
mkdir -p bin
g++ $(source) -std=c++11 -Wall -Os -lSDL2 -lSDL2_image -lSDL2_mixer -ffunction-sections -fdata-sections -Wl,--gc-sections -o $(executable)_linux
executable = super_pang_clone
source = source/*.cpp
windows:
g++ $(source) -std=c++11 -Wall -O2 -lmingw32 -lSDL2main -lSDL2 -ffunction-sections -fdata-sections -Wl,--gc-sections -static-libstdc++ -Wl,-subsystem,windows -o $(executable).exe
strip -s -R .comment -R .gnu.version $(executable).exe --strip-unneeded
macos:
g++ $(source) -std=c++11 -Wall -O2 -lSDL2 -ffunction-sections -fdata-sections -o $(executable)_macos
linux:
g++ $(source) -std=c++11 -Wall -Os -lSDL2 -ffunction-sections -fdata-sections -Wl,--gc-sections -o $(executable)_linux
strip -s -R .comment -R .gnu.version $(executable)_linux --strip-unneeded

BIN
coffee_crisis_pre_git.7z Normal file
View File

Binary file not shown.

18
media/fonts/superpowers-asset-packs-fonts/CREDIT.txt
View File

@@ -1,10 +1,10 @@
The assets in this repository are created at Sparklin Labs by Pixel-boy: https://twitter.com/2pblog1
Their creation is funded by your support on Patreon (http://patreon.com/SparklinLabs) and through donations (http://sparklinlabs.itch.io/superpowers) Thanks!
Originally downloaded from https://github.com/sparklinlabs/superpowers-asset-packs
Attribution/Licensing:
Creative Commons Zero: http://creativecommons.org/publicdomain/zero/1.0/
Attribution is not required but appreciated. Placing a link to http://superpowers-html5.com/ somewhere would be awesome :)
The assets in this repository are created at Sparklin Labs by Pixel-boy: https://twitter.com/2pblog1
Their creation is funded by your support on Patreon (http://patreon.com/SparklinLabs) and through donations (http://sparklinlabs.itch.io/superpowers) Thanks!
Originally downloaded from https://github.com/sparklinlabs/superpowers-asset-packs
Attribution/Licensing:
Creative Commons Zero: http://creativecommons.org/publicdomain/zero/1.0/
Attribution is not required but appreciated. Placing a link to http://superpowers-html5.com/ somewhere would be awesome :)
Also available at http://opengameart.org/content/superpowers-assets-bitmap-fonts

254
media/resources/nokia_cellphone/nokiafc22.txt
View File

@@ -1,127 +1,127 @@
==============================================================================
NOKIA CELLPHONE FC SMALL
========================
==============================================================================
Info
====
This is a font that emulates the bitmap font used by Nokia-based cell phones.
As the name implies ("Nokia Cellphone Small"), this is the "Small" font - used
on some menus, not the data fields (which it used a "big" font).
This was done because 1) I needed to use it on some projects and 2) I saw lots
of people asking for a font like this. So I had some experience in creating
bitmap-emulating truetype fonts (that is, a truetype, vector-based font that
works as if it was a bitmap-based font) and then I decided to do this thingie.
I send a message to my Nokia 6120 cell phone with every characters that the
cell phone had and then scanned the cellphone screens to rebuild it using
fontlab 3 and 4.
==============================================================================
How to use (read it please)
===========================
This is a "bitmap" font, a truetype font that emulates real bitmap fonts (with
no antialias, that is). It should be used at the same point size (8) or
multiples thereof (16, 24, 32) to produce the best result. When used properly,
it renders as the font found on the Nokia cellphones software.
Here's some specific hints:
Photoshop 5: use it as a normal font, with no antialias. The underline is way
too low, but I can't fix it.
Photoshop 7: use it as a normal font, with no antialias. If you're
experiencing variating vertical positions for the underline, use a fixed
leading/line spacing (10, for example) instead of the "auto" mode.
Flash: use it normally. It will not produce antialias as long as you position
your textfield on "rounded" pixels, related to the main flash stage. To do
this, draw/type your textfield on stage, go to the "Info" panel, and be sure
the topmost axis is selected (little black box) and its X and Y position are
set to a position with no decimal points (e.g., 10 and 8 instead of 10.1 and
8.5). You can embed the fonts too, *NO* antialias will occur as long as you use
it on the right positions.
==============================================================================
Modifications
=============
* VERSION 2.2 - A minor correction on wordspacing which got increased on the
last version. Now it's correct again (from 5 to 4 pixels).
* VERSION 2.1 - Small additions, due to a BIG help by Panu Tuominen from
PanuWorld (www.panuworld.net). Added characters:
<20> <20> - Y/y with acute
<20> <20> - A/a with ring
<20> <20> - Y/y with diaeresis (Y being *done from certain clues* - not sure it's right, but it probably is)
` - grave accent (unicode 0060)
* VERSION 2.0 - Took it to a new metric system (more fit for "bitmap fonts"),
fixed lots of small polygon discrepancies, and fixed some Flash filling holes
bugs. I've changed the leading too; since there's no standard leading on the
cellphone menus I've chosen one of my own.
Also, since I got a new Nokia (3310) cellphone, there's ton of new characters
available that I have added to the font. There are now 164 glyphs on the Nokia
cellphone truetype font. Here's what have been added:
<20> <20> - A/a with diaeresis
<20> <20> - E/e with grave
<20> <20> - E/e with diaeresis
<20> <20> - I/i with diaeresis
<20> <20> - I/i with circumflex
<20> <20> - O/o with grave
<20> <20> - O/o with diaeresis
<20> <20> - U/u with grave
<20> <20> - U/u with circumflex
<20> <20> - N/n with tilde
<20> <20> - O/o with slash/stroke
* * - G/g with breve (turkish codepage)
<20> - currency sign
<20> - latin capital letter AE
<20> - latin small letter AE
<20> - greek beta (I think)
<20> - Euro
* VERSION 1.4 - Fixed the WORDSPACE and LEADING size. Thanks to Gustavo Rodrigues
(from www.escritaurbana.com.br) for pointing me my mistakes. I also fixed some
mistakes on the documentation (this file).
* VERSION 1.2 - Optimized for Macromedia Flash usage (no hollows) and with
a MAC TTF version provided by Chris Moritz (members.home.net/fieldofaction3).
==============================================================================
Copyright and stuff
===================
This is a free font/file, distribute as you wish to who you wish. Do NOT sell
this font within a CD or any other media; it's not yours and you can't make
money of it. You'd rather ask me first via email, I may probably let you do it
as long as it's for a good cause.
I don't know if the original Nokia font has some copyright which prevents
people from making new fonts based on it. I hope not. Anyways, buy a Nokia,
and I think everything's gonna be alright.
Special thanks on this version go out to Carlos B<>la (www.goldenshower.gs) and
Diogo Kalil (www.sincolor.com.br) for helping me out with the Mac version of
the font. It has been extensively tested to ensure it's as smooth (hint,
kerning, spacing and aliasing-wise) as the pc one is.
==============================================================================
Author
======
This font was done by Zeh Fernando on Fontlab 4 (www.fontlab.com) on a PC.
Zeh Fernando
zeh@fatorcaos.com.br
www.fatorcaos.com.br
==============================================================================
NOKIA CELLPHONE FC SMALL
========================
==============================================================================
Info
====
This is a font that emulates the bitmap font used by Nokia-based cell phones.
As the name implies ("Nokia Cellphone Small"), this is the "Small" font - used
on some menus, not the data fields (which it used a "big" font).
This was done because 1) I needed to use it on some projects and 2) I saw lots
of people asking for a font like this. So I had some experience in creating
bitmap-emulating truetype fonts (that is, a truetype, vector-based font that
works as if it was a bitmap-based font) and then I decided to do this thingie.
I send a message to my Nokia 6120 cell phone with every characters that the
cell phone had and then scanned the cellphone screens to rebuild it using
fontlab 3 and 4.
==============================================================================
How to use (read it please)
===========================
This is a "bitmap" font, a truetype font that emulates real bitmap fonts (with
no antialias, that is). It should be used at the same point size (8) or
multiples thereof (16, 24, 32) to produce the best result. When used properly,
it renders as the font found on the Nokia cellphones software.
Here's some specific hints:
Photoshop 5: use it as a normal font, with no antialias. The underline is way
too low, but I can't fix it.
Photoshop 7: use it as a normal font, with no antialias. If you're
experiencing variating vertical positions for the underline, use a fixed
leading/line spacing (10, for example) instead of the "auto" mode.
Flash: use it normally. It will not produce antialias as long as you position
your textfield on "rounded" pixels, related to the main flash stage. To do
this, draw/type your textfield on stage, go to the "Info" panel, and be sure
the topmost axis is selected (little black box) and its X and Y position are
set to a position with no decimal points (e.g., 10 and 8 instead of 10.1 and
8.5). You can embed the fonts too, *NO* antialias will occur as long as you use
it on the right positions.
==============================================================================
Modifications
=============
* VERSION 2.2 - A minor correction on wordspacing which got increased on the
last version. Now it's correct again (from 5 to 4 pixels).
* VERSION 2.1 - Small additions, due to a BIG help by Panu Tuominen from
PanuWorld (www.panuworld.net). Added characters:
<20> <20> - Y/y with acute
<20> <20> - A/a with ring
<20> <20> - Y/y with diaeresis (Y being *done from certain clues* - not sure it's right, but it probably is)
` - grave accent (unicode 0060)
* VERSION 2.0 - Took it to a new metric system (more fit for "bitmap fonts"),
fixed lots of small polygon discrepancies, and fixed some Flash filling holes
bugs. I've changed the leading too; since there's no standard leading on the
cellphone menus I've chosen one of my own.
Also, since I got a new Nokia (3310) cellphone, there's ton of new characters
available that I have added to the font. There are now 164 glyphs on the Nokia
cellphone truetype font. Here's what have been added:
<20> <20> - A/a with diaeresis
<20> <20> - E/e with grave
<20> <20> - E/e with diaeresis
<20> <20> - I/i with diaeresis
<20> <20> - I/i with circumflex
<20> <20> - O/o with grave
<20> <20> - O/o with diaeresis
<20> <20> - U/u with grave
<20> <20> - U/u with circumflex
<20> <20> - N/n with tilde
<20> <20> - O/o with slash/stroke
* * - G/g with breve (turkish codepage)
<20> - currency sign
<20> - latin capital letter AE
<20> - latin small letter AE
<20> - greek beta (I think)
<20> - Euro
* VERSION 1.4 - Fixed the WORDSPACE and LEADING size. Thanks to Gustavo Rodrigues
(from www.escritaurbana.com.br) for pointing me my mistakes. I also fixed some
mistakes on the documentation (this file).
* VERSION 1.2 - Optimized for Macromedia Flash usage (no hollows) and with
a MAC TTF version provided by Chris Moritz (members.home.net/fieldofaction3).
==============================================================================
Copyright and stuff
===================
This is a free font/file, distribute as you wish to who you wish. Do NOT sell
this font within a CD or any other media; it's not yours and you can't make
money of it. You'd rather ask me first via email, I may probably let you do it
as long as it's for a good cause.
I don't know if the original Nokia font has some copyright which prevents
people from making new fonts based on it. I hope not. Anyways, buy a Nokia,
and I think everything's gonna be alright.
Special thanks on this version go out to Carlos B<>la (www.goldenshower.gs) and
Diogo Kalil (www.sincolor.com.br) for helping me out with the Mac version of
the font. It has been extensively tested to ensure it's as smooth (hint,
kerning, spacing and aliasing-wise) as the pc one is.
==============================================================================
Author
======
This font was done by Zeh Fernando on Fontlab 4 (www.fontlab.com) on a PC.
Zeh Fernando
zeh@fatorcaos.com.br
www.fatorcaos.com.br

60
source/background.cpp
View File

@@ -1,31 +1,31 @@
#include "background.h"
// Constructor
Background::Background()
{
init(0, 0, 0, 0, NULL);
}
// Inicializador
void Background::init(int x, int y, int w, int h, LTexture *texture)
{
// Establece el alto y el ancho del sprite del fondo
mSprite.setWidth(w);
mSprite.setHeight(h);
// Establece la posición X,Y del sprite del fondo
mSprite.setPosX(x);
mSprite.setPosY(y);
// Establece la textura donde están los gráficos para el sprite del fondo
mSprite.setTexture(*texture);
// Establece el rectangulo de donde coger la imagen
mSprite.setSpriteClip(0, 0, mSprite.getWidth(), mSprite.getHeight());
}
// Pinta el fondo en la pantalla
void Background::render()
{
mSprite.render();
#include "background.h"
// Constructor
Background::Background()
{
init(0, 0, 0, 0, NULL);
}
// Inicializador
void Background::init(int x, int y, int w, int h, LTexture *texture)
{
// Establece el alto y el ancho del sprite del fondo
mSprite.setWidth(w);
mSprite.setHeight(h);
// Establece la posición X,Y del sprite del fondo
mSprite.setPosX(x);
mSprite.setPosY(y);
// Establece la textura donde están los gráficos para el sprite del fondo
mSprite.setTexture(*texture);
// Establece el rectangulo de donde coger la imagen
mSprite.setSpriteClip(0, 0, mSprite.getWidth(), mSprite.getHeight());
}
// Pinta el fondo en la pantalla
void Background::render()
{
mSprite.render();
}

50
source/background.h
View File

@@ -1,26 +1,26 @@
#pragma once
#include "sprite.h"
#ifndef BACKGROUND_H
#define BACKGROUND_H
// Clase para el fondo de pantalla del juego
class Background
{
public:
// Constructor
Background();
// Inicializador
void init(int x, int y, int w, int h, LTexture *texture);
// Pinta el fondo en la pantalla
void render();
private:
// Variables
Sprite mSprite;
};
#pragma once
#include "sprite.h"
#ifndef BACKGROUND_H
#define BACKGROUND_H
// Clase para el fondo de pantalla del juego
class Background
{
public:
// Constructor
Background();
// Inicializador
void init(int x, int y, int w, int h, LTexture *texture);
// Pinta el fondo en la pantalla
void render();
private:
// Variables
Sprite mSprite;
};
#endif

964
source/balloon.cpp
View File

@@ -1,483 +1,483 @@
#include "balloon.h"
// Constructor
Balloon::Balloon(SDL_Renderer *gRenderer)
{
this->gRenderer = gRenderer;
gBalloonTexture = new LTexture(gRenderer);
// Carga los gráficos de los globos
if (!gBalloonTexture->loadFromFile("media/gfx/balloon.png"))
{
printf("Failed to load balloon texture!\n");
}
init(0, 0, NO_KIND, BALLON_VELX_POSITIVE, 0);
}
// Destructor
Balloon::~Balloon()
{
gBalloonTexture->free();
}
// Inicializador
void Balloon::init(int x, int y, Uint8 kind, float velx, Uint16 creationtimer)
{
switch (kind)
{
case BALLOON_1:
// Posición inicial
mPosX = x;
mPosY = y;
// Alto y ancho del objeto
mWidth = 8;
mHeight = mWidth;
// Inicializa los valores de velocidad y gravedad
mVelX = velx;
mVelY = 0;
mMaxVelY = 3;
mGravity = 0.09;
mDefaultVelY = 3;
// Puntos que da el globo al ser destruido
mScore = 50;
// Rectangulo con la imagen del sprite
mSprite.setSpriteClip(37 + 21 + 13, 0, mWidth, mHeight);
break;
case BALLOON_2:
// Posición inicial
mPosX = x;
mPosY = y;
// Alto y ancho del objeto
mWidth = 13;
mHeight = mWidth;
// Inicializa los valores de velocidad y gravedad
mVelX = velx;
mVelY = 0;
mMaxVelY = 3;
mGravity = 0.10;
mDefaultVelY = 4;
// Puntos que da el globo al ser destruido
mScore = 100;
// Rectangulo con la imagen del sprite
mSprite.setSpriteClip(37 + 21, 0, mWidth, mHeight);
break;
case BALLOON_3:
// Posición inicial
mPosX = x;
mPosY = y;
// Alto y ancho del objeto
mWidth = 21;
mHeight = mWidth;
// Inicializa los valores de velocidad y gravedad
mVelX = velx;
mVelY = 0;
mMaxVelY = 3;
mGravity = 0.10;
mDefaultVelY = 4.5;
// Puntos que da el globo al ser destruido
mScore = 200;
// Rectangulo con la imagen del sprite
mSprite.setSpriteClip(37, 0, mWidth, mHeight);
break;
case BALLOON_4:
// Posición inicial
mPosX = x;
mPosY = y;
// Alto y ancho del objeto
mWidth = 37;
mHeight = mWidth;
// Inicializa los valores de velocidad y gravedad
mVelX = velx;
mVelY = 0;
mMaxVelY = 3;
mGravity = 0.10;
mDefaultVelY = 5;
// Puntos que da el globo al ser destruido
mScore = 400;
// Rectangulo con la imagen del sprite
mSprite.setSpriteClip(0, 0, mWidth, mHeight);
break;
default:
// Posición inicial
mPosX = x;
mPosY = y;
// Alto y ancho del objeto
mWidth = 0;
mHeight = mWidth;
// Inicializa los valores de velocidad y gravedad
mVelX = velx;
mVelY = 0;
mMaxVelY = 0;
mGravity = 0;
mDefaultVelY = 0;
// Puntos que da el globo al ser destruido
mScore = 0;
// Rectangulo con la imagen del sprite
mSprite.setSpriteClip(0, 0, mWidth, mHeight);
break;
}
// Textura con los gráficos del sprite
mSprite.setTexture(*gBalloonTexture);
// Alto y ancho del sprite
mSprite.setWidth(mWidth);
mSprite.setHeight(mHeight);
// Posición X,Y del sprite
mSprite.setPosX(mPosX);
mSprite.setPosY(mPosY);
// Tamaño del circulo de colisión
mCollider.r = mWidth / 2;
// Alinea el circulo de colisión con el objeto
shiftColliders();
// Inicializa variables
mStopped = true;
mStoppedTimer = 0;
mBlinking = false;
mVisible = true;
mInvulnerable = false;
mBeingCreated = true;
mCreationTimer = creationtimer;
// Tipo
mKind = kind;
}
// Centra el globo en la posición X
void Balloon::allignTo(int x)
{
mPosX = x - (mWidth / 2);
if (mPosX < PLAY_AREA_LEFT)
{
mPosX = PLAY_AREA_LEFT + 1;
}
else if ((mPosX + mWidth) > PLAY_AREA_RIGHT)
{
mPosX = PLAY_AREA_RIGHT - mWidth - 1;
}
// Posición X,Y del sprite
mSprite.setPosX(getPosX());
mSprite.setPosY(getPosY());
// Alinea el circulo de colisión con el objeto
shiftColliders();
}
// Pinta el globo en la pantalla
void Balloon::render()
{
if (mVisible)
{
mSprite.render();
}
}
// Actualiza la posición y estados del globo
void Balloon::move()
{
// Comprobamos si se puede mover
if (isStopped() == false)
{
// Lo movemos a izquierda o derecha
mPosX += mVelX;
// Si queda fuera de pantalla, corregimos su posición y cambiamos su sentido
if ((mPosX < PLAY_AREA_LEFT) || (mPosX + mWidth > PLAY_AREA_RIGHT))
{
// Corregir posición
mPosX -= mVelX;
// Invertir sentido
mVelX = -mVelX;
}
// Mueve el globo hacia arriba o hacia abajo
mPosY += int(mVelY);
// Si se sale por arriba
if (mPosY < PLAY_AREA_TOP)
{
// Corregimos
mPosY -= int(mVelY);
// Invertimos sentido
mVelY = -mVelY;
}
// Si el globo se sale por la parte inferior
if (mPosY + mHeight > PLAY_AREA_BOTTOM)
{
// Corregimos
mPosY -= int(mVelY);
// Invertimos colocando una velocidad por defecto
mVelY = -mDefaultVelY;
}
// Aplica gravedad al objeto, sin pasarse de un limite establecido
if (int(mVelY) > mMaxVelY)
{
mVelY = mMaxVelY;
}
else
{
mVelY += mGravity;
}
// Actualiza la posición del sprite
mSprite.setPosX(getPosX());
mSprite.setPosY(mPosY);
// Actualiza la posición del circulo de colisión
shiftColliders();
}
// Si no se puede mover:
// Comprobar si se está creando
else if (isBeingCreated() == true)
{
// Actualiza el valor de las variables
setStop(true);
setInvulnerable(true);
// Todavia tiene tiempo en el contador
if (mCreationTimer > 0)
{
// Desplaza lentamente el globo hacia abajo y hacia un lado
if (mCreationTimer % 10 == 0)
{
++mPosY;
mPosX += mVelX;
// Actualiza la posición del sprite
mSprite.setPosX(getPosX());
mSprite.setPosY(mPosY);
// Actualiza la posición del circulo de colisión
shiftColliders();
}
// Hace visible el globo de forma intermitente
if (mCreationTimer > 100)
{
setVisible(mCreationTimer / 10 % 2 == 0);
}
else
{
setVisible(mCreationTimer / 5 % 2 == 0);
}
--mCreationTimer;
}
// El contador ha llegado a cero
else
{
setBeingCreated(false);
setStop(false);
setVisible(true);
setInvulnerable(false);
}
}
// Comprobar si está detenido
else if (isStopped() == true)
{
// Si todavía está detenido, reduce el contador
if (mStoppedTimer > 0)
{
--mStoppedTimer;
} // Si el contador ha llegado a cero, ya no está detenido
else
{
setStop(false);
}
}
}
// Pone a cero todos los valores del globo
void Balloon::erase()
{
init(0, 0, NO_KIND, 0, 0);
}
// Comprueba si el globo tiene algun tipo asignado
bool Balloon::isActive()
{
if (mKind == NO_KIND)
{
return false;
}
else
{
return true;
}
}
// Obtiene del valor de la variable
int Balloon::getPosX()
{
return int(mPosX);
}
// Obtiene del valor de la variable
int Balloon::getPosY()
{
return mPosY;
}
// Obtiene del valor de la variable
float Balloon::getVelY()
{
return mVelY;
}
// Obtiene del valor de la variable
int Balloon::getWidth()
{
return mWidth;
}
// Obtiene del valor de la variable
int Balloon::getHeight()
{
return mHeight;
}
// Establece el valor de la variable
void Balloon::setVelY(float velY)
{
mVelY = velY;
}
// Obtiene del valor de la variable
int Balloon::getKind()
{
return mKind;
}
// Establece el valor de la variable
void Balloon::setStop(bool state)
{
mStopped = state;
}
// Obtiene del valor de la variable
bool Balloon::isStopped()
{
return mStopped;
}
// Establece el valor de la variable
void Balloon::setBlink(bool state)
{
mBlinking = state;
}
// Obtiene del valor de la variable
bool Balloon::isBlinking()
{
return mBlinking;
}
// Establece el valor de la variable
void Balloon::setVisible(bool state)
{
mVisible = state;
}
// Obtiene del valor de la variable
bool Balloon::isVisible()
{
return mVisible;
}
// Establece el valor de la variable
void Balloon::setInvulnerable(bool state)
{
mInvulnerable = state;
}
// Obtiene del valor de la variable
bool Balloon::isInvulnerable()
{
return mInvulnerable;
}
// Establece el valor de la variable
void Balloon::setBeingCreated(bool state)
{
mBeingCreated = state;
}
// Obtiene del valor de la variable
bool Balloon::isBeingCreated()
{
return mBeingCreated;
}
// Establece el valor de la variable
void Balloon::setStoppedTimer(Uint16 time)
{
mStoppedTimer = time;
}
// Obtiene del valor de la variable
Uint16 Balloon::getStoppedTimer()
{
return mStoppedTimer;
}
// Obtiene del valor de la variable
Uint16 Balloon::getScore()
{
return mScore;
}
// Obtiene el circulo de colisión
Circle &Balloon::getCollider()
{
return mCollider;
}
// Alinea el circulo de colisión con la posición del objeto globo
void Balloon::shiftColliders()
{
// Align collider to center of balloon
mCollider.x = mPosX + mCollider.r;
mCollider.y = mPosY + mCollider.r;
#include "balloon.h"
// Constructor
Balloon::Balloon(SDL_Renderer *gRenderer)
{
this->gRenderer = gRenderer;
gBalloonTexture = new LTexture(gRenderer);
// Carga los gráficos de los globos
if (!gBalloonTexture->loadFromFile("media/gfx/balloon.png"))
{
printf("Failed to load balloon texture!\n");
}
init(0, 0, NO_KIND, BALLON_VELX_POSITIVE, 0);
}
// Destructor
Balloon::~Balloon()
{
gBalloonTexture->free();
}
// Inicializador
void Balloon::init(int x, int y, Uint8 kind, float velx, Uint16 creationtimer)
{
switch (kind)
{
case BALLOON_1:
// Posición inicial
mPosX = x;
mPosY = y;
// Alto y ancho del objeto
mWidth = 8;
mHeight = mWidth;
// Inicializa los valores de velocidad y gravedad
mVelX = velx;
mVelY = 0;
mMaxVelY = 3;
mGravity = 0.09;
mDefaultVelY = 3;
// Puntos que da el globo al ser destruido
mScore = 50;
// Rectangulo con la imagen del sprite
mSprite.setSpriteClip(37 + 21 + 13, 0, mWidth, mHeight);
break;
case BALLOON_2:
// Posición inicial
mPosX = x;
mPosY = y;
// Alto y ancho del objeto
mWidth = 13;
mHeight = mWidth;
// Inicializa los valores de velocidad y gravedad
mVelX = velx;
mVelY = 0;
mMaxVelY = 3;
mGravity = 0.10;
mDefaultVelY = 4;
// Puntos que da el globo al ser destruido
mScore = 100;
// Rectangulo con la imagen del sprite
mSprite.setSpriteClip(37 + 21, 0, mWidth, mHeight);
break;
case BALLOON_3:
// Posición inicial
mPosX = x;
mPosY = y;
// Alto y ancho del objeto
mWidth = 21;
mHeight = mWidth;
// Inicializa los valores de velocidad y gravedad
mVelX = velx;
mVelY = 0;
mMaxVelY = 3;
mGravity = 0.10;
mDefaultVelY = 4.5;
// Puntos que da el globo al ser destruido
mScore = 200;
// Rectangulo con la imagen del sprite
mSprite.setSpriteClip(37, 0, mWidth, mHeight);
break;
case BALLOON_4:
// Posición inicial
mPosX = x;
mPosY = y;
// Alto y ancho del objeto
mWidth = 37;
mHeight = mWidth;
// Inicializa los valores de velocidad y gravedad
mVelX = velx;
mVelY = 0;
mMaxVelY = 3;
mGravity = 0.10;
mDefaultVelY = 5;
// Puntos que da el globo al ser destruido
mScore = 400;
// Rectangulo con la imagen del sprite
mSprite.setSpriteClip(0, 0, mWidth, mHeight);
break;
default:
// Posición inicial
mPosX = x;
mPosY = y;
// Alto y ancho del objeto
mWidth = 0;
mHeight = mWidth;
// Inicializa los valores de velocidad y gravedad
mVelX = velx;
mVelY = 0;
mMaxVelY = 0;
mGravity = 0;
mDefaultVelY = 0;
// Puntos que da el globo al ser destruido
mScore = 0;
// Rectangulo con la imagen del sprite
mSprite.setSpriteClip(0, 0, mWidth, mHeight);
break;
}
// Textura con los gráficos del sprite
mSprite.setTexture(*gBalloonTexture);
// Alto y ancho del sprite
mSprite.setWidth(mWidth);
mSprite.setHeight(mHeight);
// Posición X,Y del sprite
mSprite.setPosX(mPosX);
mSprite.setPosY(mPosY);
// Tamaño del circulo de colisión
mCollider.r = mWidth / 2;
// Alinea el circulo de colisión con el objeto
shiftColliders();
// Inicializa variables
mStopped = true;
mStoppedTimer = 0;
mBlinking = false;
mVisible = true;
mInvulnerable = false;
mBeingCreated = true;
mCreationTimer = creationtimer;
// Tipo
mKind = kind;
}
// Centra el globo en la posición X
void Balloon::allignTo(int x)
{
mPosX = x - (mWidth / 2);
if (mPosX < PLAY_AREA_LEFT)
{
mPosX = PLAY_AREA_LEFT + 1;
}
else if ((mPosX + mWidth) > PLAY_AREA_RIGHT)
{
mPosX = PLAY_AREA_RIGHT - mWidth - 1;
}
// Posición X,Y del sprite
mSprite.setPosX(getPosX());
mSprite.setPosY(getPosY());
// Alinea el circulo de colisión con el objeto
shiftColliders();
}
// Pinta el globo en la pantalla
void Balloon::render()
{
if (mVisible)
{
mSprite.render();
}
}
// Actualiza la posición y estados del globo
void Balloon::move()
{
// Comprobamos si se puede mover
if (isStopped() == false)
{
// Lo movemos a izquierda o derecha
mPosX += mVelX;
// Si queda fuera de pantalla, corregimos su posición y cambiamos su sentido
if ((mPosX < PLAY_AREA_LEFT) || (mPosX + mWidth > PLAY_AREA_RIGHT))
{
// Corregir posición
mPosX -= mVelX;
// Invertir sentido
mVelX = -mVelX;
}
// Mueve el globo hacia arriba o hacia abajo
mPosY += int(mVelY);
// Si se sale por arriba
if (mPosY < PLAY_AREA_TOP)
{
// Corregimos
mPosY -= int(mVelY);
// Invertimos sentido
mVelY = -mVelY;
}
// Si el globo se sale por la parte inferior
if (mPosY + mHeight > PLAY_AREA_BOTTOM)
{
// Corregimos
mPosY -= int(mVelY);
// Invertimos colocando una velocidad por defecto
mVelY = -mDefaultVelY;
}
// Aplica gravedad al objeto, sin pasarse de un limite establecido
if (int(mVelY) > mMaxVelY)
{
mVelY = mMaxVelY;
}
else
{
mVelY += mGravity;
}
// Actualiza la posición del sprite
mSprite.setPosX(getPosX());
mSprite.setPosY(mPosY);
// Actualiza la posición del circulo de colisión
shiftColliders();
}
// Si no se puede mover:
// Comprobar si se está creando
else if (isBeingCreated() == true)
{
// Actualiza el valor de las variables
setStop(true);
setInvulnerable(true);
// Todavia tiene tiempo en el contador
if (mCreationTimer > 0)
{
// Desplaza lentamente el globo hacia abajo y hacia un lado
if (mCreationTimer % 10 == 0)
{
++mPosY;
mPosX += mVelX;
// Actualiza la posición del sprite
mSprite.setPosX(getPosX());
mSprite.setPosY(mPosY);
// Actualiza la posición del circulo de colisión
shiftColliders();
}
// Hace visible el globo de forma intermitente
if (mCreationTimer > 100)
{
setVisible(mCreationTimer / 10 % 2 == 0);
}
else
{
setVisible(mCreationTimer / 5 % 2 == 0);
}
--mCreationTimer;
}
// El contador ha llegado a cero
else
{
setBeingCreated(false);
setStop(false);
setVisible(true);
setInvulnerable(false);
}
}
// Comprobar si está detenido
else if (isStopped() == true)
{
// Si todavía está detenido, reduce el contador
if (mStoppedTimer > 0)
{
--mStoppedTimer;
} // Si el contador ha llegado a cero, ya no está detenido
else
{
setStop(false);
}
}
}
// Pone a cero todos los valores del globo
void Balloon::erase()
{
init(0, 0, NO_KIND, 0, 0);
}
// Comprueba si el globo tiene algun tipo asignado
bool Balloon::isActive()
{
if (mKind == NO_KIND)
{
return false;
}
else
{
return true;
}
}
// Obtiene del valor de la variable
int Balloon::getPosX()
{
return int(mPosX);
}
// Obtiene del valor de la variable
int Balloon::getPosY()
{
return mPosY;
}
// Obtiene del valor de la variable
float Balloon::getVelY()
{
return mVelY;
}
// Obtiene del valor de la variable
int Balloon::getWidth()
{
return mWidth;
}
// Obtiene del valor de la variable
int Balloon::getHeight()
{
return mHeight;
}
// Establece el valor de la variable
void Balloon::setVelY(float velY)
{
mVelY = velY;
}
// Obtiene del valor de la variable
int Balloon::getKind()
{
return mKind;
}
// Establece el valor de la variable
void Balloon::setStop(bool state)
{
mStopped = state;
}
// Obtiene del valor de la variable
bool Balloon::isStopped()
{
return mStopped;
}
// Establece el valor de la variable
void Balloon::setBlink(bool state)
{
mBlinking = state;
}
// Obtiene del valor de la variable
bool Balloon::isBlinking()
{
return mBlinking;
}
// Establece el valor de la variable
void Balloon::setVisible(bool state)
{
mVisible = state;
}
// Obtiene del valor de la variable
bool Balloon::isVisible()
{
return mVisible;
}
// Establece el valor de la variable
void Balloon::setInvulnerable(bool state)
{
mInvulnerable = state;
}
// Obtiene del valor de la variable
bool Balloon::isInvulnerable()
{
return mInvulnerable;
}
// Establece el valor de la variable
void Balloon::setBeingCreated(bool state)
{
mBeingCreated = state;
}
// Obtiene del valor de la variable
bool Balloon::isBeingCreated()
{
return mBeingCreated;
}
// Establece el valor de la variable
void Balloon::setStoppedTimer(Uint16 time)
{
mStoppedTimer = time;
}
// Obtiene del valor de la variable
Uint16 Balloon::getStoppedTimer()
{
return mStoppedTimer;
}
// Obtiene del valor de la variable
Uint16 Balloon::getScore()
{
return mScore;
}
// Obtiene el circulo de colisión
Circle &Balloon::getCollider()
{
return mCollider;
}
// Alinea el circulo de colisión con la posición del objeto globo
void Balloon::shiftColliders()
{
// Align collider to center of balloon
mCollider.x = mPosX + mCollider.r;
mCollider.y = mPosY + mCollider.r;
}

316
source/balloon.h
View File

@@ -1,159 +1,159 @@
#pragma once
#include "sprite.h"
#include "const.h"
#include "globals.h"
#ifndef BALLOON_H
#define BALLOON_H
// Clase globo
class Balloon
{
public:
// Constructor
Balloon(SDL_Renderer *gRenderer);
// Destructor
~Balloon();
// Inicializador
void init(int x, int y, Uint8 kind, float velx, Uint16 creationtimer);
// Centra el globo en la posición X
void allignTo(int x);
// Pinta el globo en la pantalla
void render();
// Actualiza la posición y estados del globo
void move();
// Pone a cero todos los valores del globo
void erase();
// Comprueba si el globo tiene algun tipo asignado
bool isActive();
// Obtiene del valor de la variable
int getPosX();
// Obtiene del valor de la variable
int getPosY();
// Obtiene del valor de la variable
float getVelY();
// Obtiene del valor de la variable
int getWidth();
// Obtiene del valor de la variable
int getHeight();
// Establece el valor de la variable
void setVelY(float velY);
// Obtiene del valor de la variable
int getKind();
// Establece el valor de la variable
void setStop(bool state);
// Obtiene del valor de la variable
bool isStopped();
// Establece el valor de la variable
void setBlink(bool state);
// Obtiene del valor de la variable
bool isBlinking();
// Establece el valor de la variable
void setVisible(bool state);
// Obtiene del valor de la variable
bool isVisible();
// Establece el valor de la variable
void setInvulnerable(bool state);
// Obtiene del valor de la variable
bool isInvulnerable();
// Establece el valor de la variable
void setBeingCreated(bool state);
// Obtiene del valor de la variable
bool isBeingCreated();
// Establece el valor de la variable
void setStoppedTimer(Uint16 time);
// Obtiene del valor de la variable
Uint16 getStoppedTimer();
// Obtiene del valor de la variable
Uint16 getScore();
// Obtiene el circulo de colisión
Circle &getCollider();
private:
// El renderizador de la ventana
SDL_Renderer *gRenderer;
LTexture *gBalloonTexture;
// Posición X,Y del objeto globo
float mPosX;
int mPosY;
// Alto y ancho del objeto globo
Uint8 mWidth;
Uint8 mHeight;
// Variables para controlar la velocidad del globo
float mVelX;
float mVelY;
float mGravity;
float mDefaultVelY;
int mMaxVelY;
// Puntos que da el globo al ser destruido
Uint16 mScore;
// Indica si el globo está parado
bool mStopped;
// Temporizador para controlar el estado "parado"
Uint16 mStoppedTimer;
// Indica si el globo está intermitente
bool mBlinking;
// Indica si el globo es visible
bool mVisible;
// Indica si el globo es invulnerable
bool mInvulnerable;
// Indica si el globo se está creando
bool mBeingCreated;
// Temporizador para controlar el estado "creandose"
Uint16 mCreationTimer;
// Tipo de globo
Uint8 mKind;
// Sprite del objeto globo
Sprite mSprite;
// Circulo de colisión del objeto
Circle mCollider;
// Alinea el circulo de colisión con la posición del objeto globo
void shiftColliders();
};
#pragma once
#include "sprite.h"
#include "const.h"
#include "globals.h"
#ifndef BALLOON_H
#define BALLOON_H
// Clase globo
class Balloon
{
public:
// Constructor
Balloon(SDL_Renderer *gRenderer);
// Destructor
~Balloon();
// Inicializador
void init(int x, int y, Uint8 kind, float velx, Uint16 creationtimer);
// Centra el globo en la posición X
void allignTo(int x);
// Pinta el globo en la pantalla
void render();
// Actualiza la posición y estados del globo
void move();
// Pone a cero todos los valores del globo
void erase();
// Comprueba si el globo tiene algun tipo asignado
bool isActive();
// Obtiene del valor de la variable
int getPosX();
// Obtiene del valor de la variable
int getPosY();
// Obtiene del valor de la variable
float getVelY();
// Obtiene del valor de la variable
int getWidth();
// Obtiene del valor de la variable
int getHeight();
// Establece el valor de la variable
void setVelY(float velY);
// Obtiene del valor de la variable
int getKind();
// Establece el valor de la variable
void setStop(bool state);
// Obtiene del valor de la variable
bool isStopped();
// Establece el valor de la variable
void setBlink(bool state);
// Obtiene del valor de la variable
bool isBlinking();
// Establece el valor de la variable
void setVisible(bool state);
// Obtiene del valor de la variable
bool isVisible();
// Establece el valor de la variable
void setInvulnerable(bool state);
// Obtiene del valor de la variable
bool isInvulnerable();
// Establece el valor de la variable
void setBeingCreated(bool state);
// Obtiene del valor de la variable
bool isBeingCreated();
// Establece el valor de la variable
void setStoppedTimer(Uint16 time);
// Obtiene del valor de la variable
Uint16 getStoppedTimer();
// Obtiene del valor de la variable
Uint16 getScore();
// Obtiene el circulo de colisión
Circle &getCollider();
private:
// El renderizador de la ventana
SDL_Renderer *gRenderer;
LTexture *gBalloonTexture;
// Posición X,Y del objeto globo
float mPosX;
int mPosY;
// Alto y ancho del objeto globo
Uint8 mWidth;
Uint8 mHeight;
// Variables para controlar la velocidad del globo
float mVelX;
float mVelY;
float mGravity;
float mDefaultVelY;
int mMaxVelY;
// Puntos que da el globo al ser destruido
Uint16 mScore;
// Indica si el globo está parado
bool mStopped;
// Temporizador para controlar el estado "parado"
Uint16 mStoppedTimer;
// Indica si el globo está intermitente
bool mBlinking;
// Indica si el globo es visible
bool mVisible;
// Indica si el globo es invulnerable
bool mInvulnerable;
// Indica si el globo se está creando
bool mBeingCreated;
// Temporizador para controlar el estado "creandose"
Uint16 mCreationTimer;
// Tipo de globo
Uint8 mKind;
// Sprite del objeto globo
Sprite mSprite;
// Circulo de colisión del objeto
Circle mCollider;
// Alinea el circulo de colisión con la posición del objeto globo
void shiftColliders();
};
#endif

417
source/bullet.cpp
View File

@@ -1,206 +1,211 @@
#include "bullet.h"
// Constructor
Bullet::Bullet(SDL_Renderer *gRenderer)
{
this->gRenderer = gRenderer;
gBulletTexture = new LTexture(gRenderer);
// Carga los gráficos de las balas
if (!gBulletTexture->loadFromFile("media/gfx/bullet.png"))
{
printf("Failed to load bullet texture!\n");
}
init(0, 0, NO_KIND);
}
// Destructor
Bullet::~Bullet()
{
gBulletTexture->free();
}
// Iniciador
void Bullet::init(int x, int y, int kind)
{
// Posición inicial del objeto
mPosX = x;
mPosY = y;
// Alto y ancho del objeto
mWidth = 8;
mHeight = mWidth;
// Velocidad inicial en el eje Y
mVelY = -3;
// Tipo de bala
mKind = kind;
// Textura con los gráficos del objeto
mSprite.setTexture(*gBulletTexture);
// Alto y ancho del sprite
mSprite.setWidth(mWidth);
mSprite.setHeight(mHeight);
// Posición inicial del sprite
mSprite.setPosX(mPosX);
mSprite.setPosY(mPosY);
// Valores especificos según el tipo
switch (kind)
{
case BULLET_UP:
// Establece la velocidad inicial
mVelX = 0;
// Rectangulo con los gráficos del objeto
mSprite.setSpriteClip(0 * mWidth, 0, mSprite.getWidth(), mSprite.getHeight());
break;
case BULLET_LEFT:
// Establece la velocidad inicial
mVelX = -2;
// Rectangulo con los gráficos del objeto
mSprite.setSpriteClip(1 * mWidth, 0, mSprite.getWidth(), mSprite.getHeight());
break;
case BULLET_RIGHT:
// Establece la velocidad inicial
mVelX = 2;
// Rectangulo con los gráficos del objeto
mSprite.setSpriteClip(2 * mWidth, 0, mSprite.getWidth(), mSprite.getHeight());
break;
default:
break;
}
// Establece el tamaño del circulo de colisión
mCollider.r = mWidth / 2;
// Alinea el circulo de colisión con el objeto
shiftColliders();
}
// Pinta el objeto en pantalla
void Bullet::render()
{
mSprite.render();
}
// Actualiza la posición y estado del objeto en horizontal
void Bullet::move()
{
// Mueve el objeto a su nueva posición
mPosX += mVelX;
// Si el objeto se sale del area de juego por los laterales
if ((mPosX < PLAY_AREA_LEFT) || (mPosX + mWidth > PLAY_AREA_RIGHT))
{
// Se deshabilita
mKind = NO_KIND;
}
// Mueve el objeto a su nueva posición en vertical
mPosY += int(mVelY);
// Si el objeto se sale del area de juego por la parte superior o inferior
if ((mPosY < PLAY_AREA_TOP) || (mPosY + mHeight > PLAY_AREA_BOTTOM))
{
// Se deshabilita
mKind = NO_KIND;
}
// Actualiza la posición del sprite
mSprite.setPosX(mPosX);
mSprite.setPosY(mPosY);
// Alinea el circulo de colisión con el objeto
shiftColliders();
}
#ifdef TEST
void Bullet::testMove()
{
// Update sprite position
mSprite.setPosX(mPosX);
mSprite.setPosY(mPosY);
// Update circle colliders
shiftColliders();
}
#endif
// Deshabilita el objeto
void Bullet::erase()
{
mKind = NO_KIND;
}
// Comprueba si el objeto está activo
bool Bullet::isActive()
{
if (mKind == NO_KIND)
{
return false;
}
else
{
return true;
}
}
// Obtiene el valor de la variable
int Bullet::getPosX()
{
return mPosX;
}
// Obtiene el valor de la variable
int Bullet::getPosY()
{
return mPosY;
}
// Establece el valor de la variable
void Bullet::setPosX(int x)
{
mPosX = x;
}
// Establece el valor de la variable
void Bullet::setPosY(int y)
{
mPosY = y;
}
// Obtiene el valor de la variable
float Bullet::getVelY()
{
return mVelY;
}
// Obtiene el valor de la variable
int Bullet::getKind()
{
return mKind;
}
// Obtiene el circulo de colisión
Circle &Bullet::getCollider()
{
return mCollider;
}
// Alinea el circulo de colisión con el objeto
void Bullet::shiftColliders()
{
mCollider.x = mPosX + mCollider.r;
mCollider.y = mPosY + mCollider.r;
}
#include "bullet.h"
// Constructor
Bullet::Bullet(SDL_Renderer *gRenderer)
{
this->gRenderer = gRenderer;
gBulletTexture = new LTexture(gRenderer);
// Carga los gráficos de las balas
if (!gBulletTexture->loadFromFile("media/gfx/bullet.png"))
{
printf("Failed to load bullet texture!\n");
}
init(0, 0, NO_KIND);
}
// Destructor
Bullet::~Bullet()
{
gBulletTexture->free();
}
// Iniciador
void Bullet::init(int x, int y, int kind)
{
// Posición inicial del objeto
mPosX = x;
mPosY = y;
// Alto y ancho del objeto
mWidth = 8;
mHeight = mWidth;
// Velocidad inicial en el eje Y
mVelY = -3;
// Tipo de bala
mKind = kind;
// Textura con los gráficos del objeto
mSprite.setTexture(*gBulletTexture);
// Alto y ancho del sprite
mSprite.setWidth(mWidth);
mSprite.setHeight(mHeight);
// Posición inicial del sprite
mSprite.setPosX(mPosX);
mSprite.setPosY(mPosY);
// Valores especificos según el tipo
switch (kind)
{
case BULLET_UP:
// Establece la velocidad inicial
mVelX = 0;
// Rectangulo con los gráficos del objeto
mSprite.setSpriteClip(0 * mWidth, 0, mSprite.getWidth(), mSprite.getHeight());
break;
case BULLET_LEFT:
// Establece la velocidad inicial
mVelX = -2;
// Rectangulo con los gráficos del objeto
mSprite.setSpriteClip(1 * mWidth, 0, mSprite.getWidth(), mSprite.getHeight());
break;
case BULLET_RIGHT:
// Establece la velocidad inicial
mVelX = 2;
// Rectangulo con los gráficos del objeto
mSprite.setSpriteClip(2 * mWidth, 0, mSprite.getWidth(), mSprite.getHeight());
break;
default:
// Establece la velocidad inicial
mVelX = 0;
// Rectangulo con los gráficos del objeto
mSprite.setSpriteClip(0 * mWidth, 0, mSprite.getWidth(), mSprite.getHeight());
break;
}
// Establece el tamaño del circulo de colisión
mCollider.r = mWidth / 2;
// Alinea el circulo de colisión con el objeto
shiftColliders();
}
// Pinta el objeto en pantalla
void Bullet::render()
{
mSprite.render();
}
// Actualiza la posición y estado del objeto en horizontal
void Bullet::move()
{
// Mueve el objeto a su nueva posición
mPosX += mVelX;
// Si el objeto se sale del area de juego por los laterales
if ((mPosX < PLAY_AREA_LEFT) || (mPosX + mWidth > PLAY_AREA_RIGHT))
{
// Se deshabilita
mKind = NO_KIND;
}
// Mueve el objeto a su nueva posición en vertical
mPosY += int(mVelY);
// Si el objeto se sale del area de juego por la parte superior o inferior
if ((mPosY < PLAY_AREA_TOP) || (mPosY + mHeight > PLAY_AREA_BOTTOM))
{
// Se deshabilita
mKind = NO_KIND;
}
// Actualiza la posición del sprite
mSprite.setPosX(mPosX);
mSprite.setPosY(mPosY);
// Alinea el circulo de colisión con el objeto
shiftColliders();
}
#ifdef TEST
void Bullet::testMove()
{
// Update sprite position
mSprite.setPosX(mPosX);
mSprite.setPosY(mPosY);
// Update circle colliders
shiftColliders();
}
#endif
// Deshabilita el objeto
void Bullet::erase()
{
mKind = NO_KIND;
}
// Comprueba si el objeto está activo
bool Bullet::isActive()
{
if (mKind == NO_KIND)
{
return false;
}
else
{
return true;
}
}
// Obtiene el valor de la variable
int Bullet::getPosX()
{
return mPosX;
}
// Obtiene el valor de la variable
int Bullet::getPosY()
{
return mPosY;
}
// Establece el valor de la variable
void Bullet::setPosX(int x)
{
mPosX = x;
}
// Establece el valor de la variable
void Bullet::setPosY(int y)
{
mPosY = y;
}
// Obtiene el valor de la variable
float Bullet::getVelY()
{
return mVelY;
}
// Obtiene el valor de la variable
int Bullet::getKind()
{
return mKind;
}
// Obtiene el circulo de colisión
Circle &Bullet::getCollider()
{
return mCollider;
}
// Alinea el circulo de colisión con el objeto
void Bullet::shiftColliders()
{
mCollider.x = mPosX + mCollider.r;
mCollider.y = mPosY + mCollider.r;
}

176
source/bullet.h
View File

@@ -1,89 +1,89 @@
#pragma once
#include "sprite.h"
#include "const.h"
#include "globals.h"
#ifndef BULLET_H
#define BULLET_H
// Clase bala
class Bullet
{
public:
// Constructor
Bullet(SDL_Renderer *gRenderer);
// Destructor
~Bullet();
// Iniciador
void init(int x, int y, int kind);
// Pinta el objeto en pantalla
void render();
// Actualiza la posición y estado del objeto
void move();
#ifdef TEST
void testMove();
#endif
// Deshabilita el objeto
void erase();
// Comprueba si el objeto está activo
bool isActive();
// Obtiene el valor de la variable
int getPosX();
// Obtiene el valor de la variable
int getPosY();
// Establece el valor de la variable
void setPosX(int x);
// Establece el valor de la variable
void setPosY(int y);
// Obtiene el valor de la variable
float getVelY();
// Obtiene el valor de la variable
int getKind();
// Obtiene el circulo de colisión
Circle &getCollider();
private:
// El renderizador de la ventana
SDL_Renderer *gRenderer;
LTexture *gBulletTexture;
// Posición X/Y del objeto
int mPosX;
int mPosY;
// Alto y ancho el objeto
Uint8 mWidth;
Uint8 mHeight;
// Velocidad del objeto
int mVelX;
int mVelY;
// Tipo de objeto
int mKind;
// Sprite con los graficos y métodos de pintado
Sprite mSprite;
// Balloon's collision circle
Circle mCollider;
// Alinea el circulo de colisión con el objeto
void shiftColliders();
};
#pragma once
#include "sprite.h"
#include "const.h"
#include "globals.h"
#ifndef BULLET_H
#define BULLET_H
// Clase bala
class Bullet
{
public:
// Constructor
Bullet(SDL_Renderer *gRenderer);
// Destructor
~Bullet();
// Iniciador
void init(int x, int y, int kind);
// Pinta el objeto en pantalla
void render();
// Actualiza la posición y estado del objeto
void move();
#ifdef TEST
void testMove();
#endif
// Deshabilita el objeto
void erase();
// Comprueba si el objeto está activo
bool isActive();
// Obtiene el valor de la variable
int getPosX();
// Obtiene el valor de la variable
int getPosY();
// Establece el valor de la variable
void setPosX(int x);
// Establece el valor de la variable
void setPosY(int y);
// Obtiene el valor de la variable
float getVelY();
// Obtiene el valor de la variable
int getKind();
// Obtiene el circulo de colisión
Circle &getCollider();
private:
// El renderizador de la ventana
SDL_Renderer *gRenderer;
LTexture *gBulletTexture;
// Posición X/Y del objeto
int mPosX;
int mPosY;
// Alto y ancho el objeto
Uint8 mWidth;
Uint8 mHeight;
// Velocidad del objeto
int mVelX;
int mVelY;
// Tipo de objeto
int mKind;
// Sprite con los graficos y métodos de pintado
Sprite mSprite;
// Balloon's collision circle
Circle mCollider;
// Alinea el circulo de colisión con el objeto
void shiftColliders();
};
#endif

210
source/const.h
View File

@@ -1,106 +1,106 @@
#pragma once
#ifndef CONST_H
#define CONST_H
// Tamaño de bloque
const int BLOCK = 8;
// Tamaño de la pantalla real
const int SCREEN_WIDTH = 256;
const int SCREEN_HEIGHT = SCREEN_WIDTH * 3 / 4;
// Tamaño de la pantalla que se muestra
const int VIEW_WIDTH = SCREEN_WIDTH * 3;
const int VIEW_HEIGHT = SCREEN_HEIGHT * 3;
// Zona de juego
const int PLAY_AREA_TOP = (0 * BLOCK);
const int PLAY_AREA_BOTTOM = SCREEN_HEIGHT - (4 * BLOCK);
const int PLAY_AREA_LEFT = (0 * BLOCK);
const int PLAY_AREA_RIGHT = SCREEN_WIDTH - (0 * BLOCK);
const int PLAY_AREA_WIDTH = PLAY_AREA_RIGHT - PLAY_AREA_LEFT;
const int PLAY_AREA_HEIGHT = PLAY_AREA_BOTTOM - PLAY_AREA_TOP;
// Color transparente para los sprites
const int COLOR_KEY_R = 0xff;
const int COLOR_KEY_G = 0x00;
const int COLOR_KEY_B = 0xff;
// Opciones de menu
const int MENU_NO_OPTION = -1;
const int MENU_OPTION_START = 0;
const int MENU_OPTION_QUIT = 1;
const int MENU_OPTION_TOTAL = 2;
// Selector de menu
const int MENU_SELECTOR_BLACK = (BLOCK * 0);
const int MENU_SELECTOR_WHITE = (BLOCK * 1);
// Tipos de fondos para el menu
const int MENU_BACKGROUND_TRANSPARENT = 0;
const int MENU_BACKGROUND_SOLID = 1;
// Estados del jugador
const int PLAYER_STATE_STOPPED = 0;
const int PLAYER_STATE_WALKING_LEFT = 1;
const int PLAYER_STATE_WALKING_RIGHT = 2;
const int PLAYER_STATE_TOTAL = 3;
// Estados del juego
const int GAME_STATE_TITLE = 0;
const int GAME_STATE_PLAYING = 1;
const int GAME_STATE_PAUSED = 2;
const int GAME_STATE_QUIT = 3;
const int GAME_STATE_TOTAL = 4;
// Anclajes para el marcador de puntos
const int SCORE_WORD_X = (SCREEN_WIDTH / 4) - ((5 * BLOCK) / 2);
const int SCORE_WORD_Y = SCREEN_HEIGHT - (3 * BLOCK) + 4;
const int SCORE_NUMBER_X = (SCREEN_WIDTH / 4) - (3 * BLOCK);
const int SCORE_NUMBER_Y = SCREEN_HEIGHT - (2 * BLOCK) + 4;
const int HISCORE_WORD_X = ((SCREEN_WIDTH / 4) * 3) - ((8 * BLOCK) / 2);
const int HISCORE_WORD_Y = SCREEN_HEIGHT - (3 * BLOCK) + 4;
const int HISCORE_NUMBER_X = ((SCREEN_WIDTH / 4) * 3) - (3 * BLOCK);
const int HISCORE_NUMBER_Y = SCREEN_HEIGHT - (2 * BLOCK) + 4;
// Ningun tipo
const int NO_KIND = 0;
// Tipos de globo
const int BALLOON_1 = 1;
const int BALLOON_2 = 2;
const int BALLOON_3 = 3;
const int BALLOON_4 = 4;
// Velocidad del globo
const float BALLON_VELX_POSITIVE = 0.7;
const float BALLON_VELX_NEGATIVE = -0.7;
// Tipos de bala
const int BULLET_UP = 1;
const int BULLET_LEFT = 2;
const int BULLET_RIGHT = 3;
// Estados de entrada
const int NO_INPUT = 0;
const int INPUT_UP = 1;
const int INPUT_DOWN = 2;
const int INPUT_LEFT = 3;
const int INPUT_RIGHT = 4;
const int INPUT_FIRE = 5;
// Zona muerta del mando analógico
const int JOYSTICK_DEAD_ZONE = 8000;
// Mapeo de bottones (8bitdo)
const int BUTTON_A = 0;
const int BUTTON_B = 1;
const int BUTTON_X = 3;
const int BUTTON_Y = 4;
const int BUTTON_SELECT = 10;
const int BUTTON_START = 11;
const int BUTTON_L = 6;
const int BUTTON_R = 7;
#pragma once
#ifndef CONST_H
#define CONST_H
// Tamaño de bloque
const int BLOCK = 8;
// Tamaño de la pantalla real
const int SCREEN_WIDTH = 256;
const int SCREEN_HEIGHT = SCREEN_WIDTH * 3 / 4;
// Tamaño de la pantalla que se muestra
const int VIEW_WIDTH = SCREEN_WIDTH * 3;
const int VIEW_HEIGHT = SCREEN_HEIGHT * 3;
// Zona de juego
const int PLAY_AREA_TOP = (0 * BLOCK);
const int PLAY_AREA_BOTTOM = SCREEN_HEIGHT - (4 * BLOCK);
const int PLAY_AREA_LEFT = (0 * BLOCK);
const int PLAY_AREA_RIGHT = SCREEN_WIDTH - (0 * BLOCK);
const int PLAY_AREA_WIDTH = PLAY_AREA_RIGHT - PLAY_AREA_LEFT;
const int PLAY_AREA_HEIGHT = PLAY_AREA_BOTTOM - PLAY_AREA_TOP;
// Color transparente para los sprites
const int COLOR_KEY_R = 0xff;
const int COLOR_KEY_G = 0x00;
const int COLOR_KEY_B = 0xff;
// Opciones de menu
const int MENU_NO_OPTION = -1;
const int MENU_OPTION_START = 0;
const int MENU_OPTION_QUIT = 1;
const int MENU_OPTION_TOTAL = 2;
// Selector de menu
const int MENU_SELECTOR_BLACK = (BLOCK * 0);
const int MENU_SELECTOR_WHITE = (BLOCK * 1);
// Tipos de fondos para el menu
const int MENU_BACKGROUND_TRANSPARENT = 0;
const int MENU_BACKGROUND_SOLID = 1;
// Estados del jugador
const int PLAYER_STATE_STOPPED = 0;
const int PLAYER_STATE_WALKING_LEFT = 1;
const int PLAYER_STATE_WALKING_RIGHT = 2;
const int PLAYER_STATE_TOTAL = 3;
// Estados del juego
const int GAME_STATE_TITLE = 0;
const int GAME_STATE_PLAYING = 1;
const int GAME_STATE_PAUSED = 2;
const int GAME_STATE_QUIT = 3;
const int GAME_STATE_TOTAL = 4;
// Anclajes para el marcador de puntos
const int SCORE_WORD_X = (SCREEN_WIDTH / 4) - ((5 * BLOCK) / 2);
const int SCORE_WORD_Y = SCREEN_HEIGHT - (3 * BLOCK) + 4;
const int SCORE_NUMBER_X = (SCREEN_WIDTH / 4) - (3 * BLOCK);
const int SCORE_NUMBER_Y = SCREEN_HEIGHT - (2 * BLOCK) + 4;
const int HISCORE_WORD_X = ((SCREEN_WIDTH / 4) * 3) - ((8 * BLOCK) / 2);
const int HISCORE_WORD_Y = SCREEN_HEIGHT - (3 * BLOCK) + 4;
const int HISCORE_NUMBER_X = ((SCREEN_WIDTH / 4) * 3) - (3 * BLOCK);
const int HISCORE_NUMBER_Y = SCREEN_HEIGHT - (2 * BLOCK) + 4;
// Ningun tipo
const int NO_KIND = 0;
// Tipos de globo
const int BALLOON_1 = 1;
const int BALLOON_2 = 2;
const int BALLOON_3 = 3;
const int BALLOON_4 = 4;
// Velocidad del globo
const float BALLON_VELX_POSITIVE = 0.7;
const float BALLON_VELX_NEGATIVE = -0.7;
// Tipos de bala
const int BULLET_UP = 1;
const int BULLET_LEFT = 2;
const int BULLET_RIGHT = 3;
// Estados de entrada
const int NO_INPUT = 0;
const int INPUT_UP = 1;
const int INPUT_DOWN = 2;
const int INPUT_LEFT = 3;
const int INPUT_RIGHT = 4;
const int INPUT_FIRE = 5;
// Zona muerta del mando analógico
const int JOYSTICK_DEAD_ZONE = 8000;
// Mapeo de bottones (8bitdo)
const int BUTTON_A = 0;
const int BUTTON_B = 1;
const int BUTTON_X = 3;
const int BUTTON_Y = 4;
const int BUTTON_SELECT = 10;
const int BUTTON_START = 11;
const int BUTTON_L = 6;
const int BUTTON_R = 7;
#endif

2046
source/gamedirector.cpp
View File

File diff suppressed because it is too large Load Diff

438
source/gamedirector.h
View File

@@ -1,219 +1,221 @@
#pragma once
#include "background.h"
#include "balloon.h"
#include "bullet.h"
#include "const.h"
#include "globals.h"
#include "ltexture.h"
#include "menu.h"
#include "player.h"
#include "text.h"
#ifndef GAMEDIRECTOR_H
#define GAMEDIRECTOR_H
// GameDirector
class GameDirector
{
public:
// Constructor
GameDirector(SDL_Renderer *gRenderer);
// Destructor
~GameDirector();
// Iniciador
void init();
// Hace una pausa de milisegundos
void sleep(Uint16 time);
// Establece el valor de la variable
void setScore(Uint32 score);
// Establece el valor de la variable
void setHiScore(Uint32 score);
// Actualiza el valor de HiScore en caso necesario
void updateHiScore();
// Transforma un valor numérico en una cadena de 6 cifras
std::string updateScoreText(Uint32 num);
// Pinta el marcador en pantalla usando un objeto texto
void renderScoreBoard(Text &text);
// Mueve todos los globos activos
void moveBalloons();
// Pinta en pantalla todos los globos activos
void renderBalloons();
// Devuelve el primer indice no activo del vector de globos
Uint8 getBallonFreeIndex();
// Crea un globo nuevo en el vector de globos
Uint8 createNewBalloon(int x, int y, Uint8 kind, float velx, Uint16 stoppedtimer);
// Establece a cero todos los valores del vector de objetos globo
void resetBalloons();
// Explosiona un globo. Lo destruye y crea otros dos si es el caso
void popBalloon(Uint8 index);
// Detiene todos los globos
void stopAllBalloons();
// Pone en marcha todos los globos
void startAllBalloons();
// Obtiene el numero de globos activos
Uint8 countBalloons();
// Comprueba la colisión entre el jugador y los globos activos
bool checkPlayerBallonCollision();
// Comprueba y procesa la colisión entre las balas y los globos
void processBulletBallonCollision();
// Mueve las balas activas
void moveBullets();
// Pinta las balas activas
void renderBullets();
// Devuelve el primer indice no activo del vector de balas
Uint8 getBulletFreeIndex();
// Establece a cero todos los valores del vector de objetos bala
void resetBullets();
// Crea un objeto bala
void createBullet(int x, int y, Uint8 kind);
// Calcula y establece el valor de amenaza en funcion de los globos activos
void calculateMenaceLevel();
// Obtiene el valor de la variable
Uint8 getMenaceLevel();
// Gestiona el nivel de amenaza
void checkMenaceLevel();
// Gestiona la entrada de teclado y mando durante el juego
void checkGameInput();
// Gestiona la entrada de teclado y mando durante el menu
void checkMenuInput(Menu *menu);
// Obtiene el valor de la variable
Uint8 getGameStatus();
// Establece el valor de la variable
void setGameStatus(Uint8 status);
// Pinta una transición en pantalla
void renderTransition(Uint8 index);
// Pinta el texto GetReady en pantalla
void renderGetReady();
// Bucle para el titulo del juego
void runTitle();
// Bucle para el juego
void runGame();
// Bucle para el menu de pausa del juego
void runPausedGame();
private:
// El renderizador de la ventana
SDL_Renderer *gRenderer = NULL;
// Objetos con la música del juego
Mix_Music *gTitleMusic = NULL;
Mix_Music *gPlayingMusic = NULL;
// Objetos con los efectos de sonido del juego
Mix_Chunk *gPopBalloonFX = NULL;
Mix_Chunk *gBulletFX = NULL;
// Manejador para el mando 1
SDL_Joystick *gGameController = NULL;
// Texturas
LTexture *gGameBackgroundTexture;
LTexture *gTitleBackgroundTexture;
LTexture *gWhiteFontTexture;
LTexture *gBlackFontTexture;
LTexture *gMiscTexture;
// Manejador de eventos
SDL_Event eventHandler;
// El jugador
Player *player;
// Vector con los objetos globo
Balloon *balloon[50];
#ifdef TEST
Balloon balloonTest;
Bullet bulletTest;
#endif
// Vector con los objetos bala
Bullet *bullet[50];
// Fondo del juego
Background gameBackground;
// Fondo de la pantalla de titulo
Background titleBackground;
// Texto blanco
Text whiteText;
// Texto negro
Text blackText;
// Menu de la pantalla de título
Menu *menuTitle;
// Menú de la pantalla de pausa
Menu *menuPause;
// Indicador para el bucle principal
Uint8 mGameStatus;
// Puntuación actual y puntuación máxima
Uint32 mScore;
Uint32 mHiScore;
// Cadena de texto con la puntuación actual y la puntuación máxima de 6 cifras
std::string mScoreText;
std::string mHiScoreText;
// Número máximo de globos y balas que puede almacenar el vector
Uint8 mMaxBalloons;
Uint8 mMaxBullets;
// Contador de ticks para ajustar la velocidad del juego
Uint32 mOldTicks;
// Velocidad a la que se repite el bucle de juego
Uint8 mGameSpeed;
// Nivel de amenaza actual
Uint8 mMenaceLevel;
// Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral,
// se generan más globos. Si el umbral aumenta, aumenta el numero de globos
Uint8 mMenaceLevelThreshold;
// Indica si ha de aparecer el texto de GetReady en pantalla
bool mGetReady;
};
#pragma once
#include "background.h"
#include "balloon.h"
#include "bullet.h"
#include "const.h"
#include "globals.h"
#include "ltexture.h"
#include "menu.h"
#include "player.h"
#include "text.h"
#include "jail_audio.h"
#ifndef GAMEDIRECTOR_H
#define GAMEDIRECTOR_H
// GameDirector
class GameDirector
{
public:
// Constructor
GameDirector(SDL_Renderer *gRenderer);
// Destructor
~GameDirector();
// Iniciador
void init();
// Establece el valor de la variable
void setScore(Uint32 score);
// Establece el valor de la variable
void setHiScore(Uint32 score);
// Actualiza el valor de HiScore en caso necesario
void updateHiScore();
// Transforma un valor numérico en una cadena de 6 cifras
std::string updateScoreText(Uint32 num);
// Pinta el marcador en pantalla usando un objeto texto
void renderScoreBoard(Text &text);
// Mueve todos los globos activos
void moveBalloons();
// Pinta en pantalla todos los globos activos
void renderBalloons();
// Devuelve el primer indice no activo del vector de globos
Uint8 getBallonFreeIndex();
// Crea un globo nuevo en el vector de globos
Uint8 createNewBalloon(int x, int y, Uint8 kind, float velx, Uint16 stoppedtimer);
// Establece a cero todos los valores del vector de objetos globo
void resetBalloons();
// Explosiona un globo. Lo destruye y crea otros dos si es el caso
void popBalloon(Uint8 index);
// Detiene todos los globos
void stopAllBalloons();
// Pone en marcha todos los globos
void startAllBalloons();
// Obtiene el numero de globos activos
Uint8 countBalloons();
// Comprueba la colisión entre el jugador y los globos activos
bool checkPlayerBallonCollision();
// Comprueba y procesa la colisión entre las balas y los globos
void processBulletBallonCollision();
// Mueve las balas activas
void moveBullets();
// Pinta las balas activas
void renderBullets();
// Devuelve el primer indice no activo del vector de balas
Uint8 getBulletFreeIndex();
// Establece a cero todos los valores del vector de objetos bala
void resetBullets();
// Crea un objeto bala
void createBullet(int x, int y, Uint8 kind);
// Calcula y establece el valor de amenaza en funcion de los globos activos
void calculateMenaceLevel();
// Obtiene el valor de la variable
Uint8 getMenaceLevel();
// Gestiona el nivel de amenaza
void checkMenaceLevel();
// Gestiona la entrada de teclado y mando durante el juego
void checkGameInput();
// Gestiona la entrada de teclado y mando durante el menu
void checkMenuInput(Menu *menu);
// Obtiene el valor de la variable
Uint8 getGameStatus();
// Establece el valor de la variable
void setGameStatus(Uint8 status);
// Pinta una transición en pantalla
void renderTransition(Uint8 index);
// Pinta el texto GetReady en pantalla
void renderGetReady();
// Bucle para el titulo del juego
void runTitle();
// Bucle para el juego
void runGame();
// Bucle para el menu de pausa del juego
void runPausedGame();
private:
// El renderizador de la ventana
SDL_Renderer *gRenderer = NULL;
// Objetos con la música del juego
//Mix_Music *gTitleMusic = NULL;
//Mix_Music *gPlayingMusic = NULL;
JA_Music gTitleMusic;
JA_Music gPlayingMusic;
// Objetos con los efectos de sonido del juego
//Mix_Chunk *gPopBalloonFX = NULL;
//Mix_Chunk *gBulletFX = NULL;
JA_Sound gPopBalloonFX;
JA_Sound gBulletFX;
// Manejador para el mando 1
SDL_Joystick *gGameController = NULL;
// Texturas
LTexture *gGameBackgroundTexture;
LTexture *gTitleBackgroundTexture;
LTexture *gWhiteFontTexture;
LTexture *gBlackFontTexture;
LTexture *gMiscTexture;
// Manejador de eventos
SDL_Event eventHandler;
// El jugador
Player *player;
// Vector con los objetos globo
Balloon *balloon[50];
#ifdef TEST
Balloon balloonTest;
Bullet bulletTest;
#endif
// Vector con los objetos bala
Bullet *bullet[50];
// Fondo del juego
Background gameBackground;
// Fondo de la pantalla de titulo
Background titleBackground;
// Texto blanco
Text whiteText;
// Texto negro
Text blackText;
// Menu de la pantalla de título
Menu *menuTitle;
// Menú de la pantalla de pausa
Menu *menuPause;
// Indicador para el bucle principal
Uint8 mGameStatus;
// Puntuación actual y puntuación máxima
Uint32 mScore;
Uint32 mHiScore;
// Cadena de texto con la puntuación actual y la puntuación máxima de 6 cifras
std::string mScoreText;
std::string mHiScoreText;
// Número máximo de globos y balas que puede almacenar el vector
Uint8 mMaxBalloons;
Uint8 mMaxBullets;
// Contador de ticks para ajustar la velocidad del juego
Uint32 mOldTicks;
// Velocidad a la que se repite el bucle de juego
Uint8 mGameSpeed;
// Nivel de amenaza actual
Uint8 mMenaceLevel;
// Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral,
// se generan más globos. Si el umbral aumenta, aumenta el numero de globos
Uint8 mMenaceLevelThreshold;
// Indica si ha de aparecer el texto de GetReady en pantalla
bool mGetReady;
};
#endif

32
source/globals.h
View File

@@ -1,18 +1,16 @@
#pragma once
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <SDL2/SDL_mixer.h>
#ifndef GLOBALS_H
#define GLOBALS_H
// Estructura para definir un circulo
struct Circle
{
Uint16 x;
Uint16 y;
Uint8 r;
};
#pragma once
#include <SDL2/SDL.h>
#ifndef GLOBALS_H
#define GLOBALS_H
// Estructura para definir un circulo
struct Circle
{
Uint16 x;
Uint16 y;
Uint8 r;
};
#endif

238
source/jail_audio.cpp Normal file
View File

@@ -0,0 +1,238 @@
#include "jail_audio.h"
#include "stb_vorbis.c"
#include <SDL2/SDL.h>
#include <stdio.h>
#define JA_MAX_SIMULTANEOUS_CHANNELS 5
struct JA_Sound_t {
Uint32 length {0};
Uint8* buffer {NULL};
};
struct JA_Channel_t {
JA_Sound sound;
int pos {0};
int times {0};
JA_Channel_state state { JA_CHANNEL_FREE };
};
struct JA_Music_t {
int samples {0};
int pos {0};
int times {0};
short* output {NULL};
JA_Music_state state {JA_MUSIC_INVALID};
};
JA_Music current_music{NULL};
JA_Channel_t channels[JA_MAX_SIMULTANEOUS_CHANNELS];
int JA_freq {48000};
SDL_AudioFormat JA_format {AUDIO_S16};
Uint8 JA_channels {2};
int JA_volume = 128;
void audioCallback(void * userdata, uint8_t * stream, int len) {
SDL_memset(stream, 0, len);
if (current_music != NULL && current_music->state == JA_MUSIC_PLAYING) {
const int size = SDL_min(len, current_music->samples*2-current_music->pos);
SDL_MixAudioFormat(stream, (Uint8*)(current_music->output+current_music->pos), AUDIO_S16, size, JA_volume);
current_music->pos += size/2;
if (size < len) {
if (current_music->times != 0) {
SDL_MixAudioFormat(stream+size, (Uint8*)current_music->output, AUDIO_S16, len-size, JA_volume);
current_music->pos = (len-size)/2;
if (current_music->times > 0) current_music->times--;
} else {
current_music->pos = 0;
current_music->state = JA_MUSIC_STOPPED;
}
}
}
// Mixar els channels mi amol
for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
if (channels[i].state == JA_CHANNEL_PLAYING) {
const int size = SDL_min(len, channels[i].sound->length - channels[i].pos);
SDL_MixAudioFormat(stream, channels[i].sound->buffer + channels[i].pos, AUDIO_S16, size, JA_volume/2);
channels[i].pos += size;
if (size < len) {
if (channels[i].times != 0) {
SDL_MixAudioFormat(stream + size, channels[i].sound->buffer, AUDIO_S16, len-size, JA_volume/2);
channels[i].pos = len-size;
if (channels[i].times > 0) channels[i].times--;
} else {
JA_StopChannel(i);
}
}
}
}
}
void JA_Init(const int freq, const SDL_AudioFormat format, const int channels) {
JA_freq = freq;
JA_format = format;
JA_channels = channels;
SDL_AudioSpec audioSpec{JA_freq, JA_format, JA_channels, 0, 1024, 0, 0, audioCallback, NULL};
SDL_AudioDeviceID sdlAudioDevice = SDL_OpenAudioDevice(NULL, 0, &audioSpec, NULL, 0);
SDL_PauseAudioDevice(sdlAudioDevice, 0);
}
JA_Music JA_LoadMusic(const char* filename) {
int chan, samplerate;
JA_Music music = new JA_Music_t();
// [RZC 28/08/22] Carreguem primer el arxiu en memòria i després el descomprimim. Es algo més rapid.
FILE *f = fopen(filename, "rb");
fseek(f, 0, SEEK_END);
long fsize = ftell(f);
fseek(f, 0, SEEK_SET);
Uint8 *buffer = (Uint8*)malloc(fsize + 1);
fread(buffer, fsize, 1, f);
fclose(f);
music->samples = stb_vorbis_decode_memory(buffer, fsize, &chan, &samplerate, &music->output);
free(buffer);
// [RZC 28/08/22] Abans el descomprimiem mentre el teniem obert
// music->samples = stb_vorbis_decode_filename(filename, &chan, &samplerate, &music->output);
SDL_AudioCVT cvt;
SDL_BuildAudioCVT(&cvt, AUDIO_S16, chan, samplerate, JA_format, JA_channels, JA_freq);
cvt.len = music->samples * chan * 2;
cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult);
SDL_memcpy(cvt.buf, music->output, cvt.len);
SDL_ConvertAudio(&cvt);
free(music->output);
music->output = (short*)cvt.buf;
music->pos = 0;
music->state = JA_MUSIC_STOPPED;
return music;
}
void JA_PlayMusic(JA_Music music, const int loop) {
if (current_music != NULL) {
current_music->pos = 0;
current_music->state = JA_MUSIC_STOPPED;
}
current_music = music;
current_music->pos = 0;
current_music->state = JA_MUSIC_PLAYING;
current_music->times = loop;
}
void JA_PauseMusic() {
if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
current_music->state = JA_MUSIC_PAUSED;
}
void JA_ResumeMusic() {
if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
current_music->state = JA_MUSIC_PLAYING;
}
void JA_StopMusic() {
if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
current_music->pos = 0;
current_music->state = JA_MUSIC_STOPPED;
}
JA_Music_state JA_GetMusicState() {
if (current_music == NULL) return JA_MUSIC_INVALID;
return current_music->state;
}
void JA_DeleteMusic(JA_Music music) {
if (current_music == music) current_music = NULL;
SDL_free(music->output);
delete music;
}
JA_Sound JA_NewSound(Uint8* buffer, Uint32 length) {
JA_Sound sound = new JA_Sound_t();
sound->buffer = buffer;
sound->length = length;
return sound;
}
JA_Sound JA_LoadSound(const char* filename) {
JA_Sound sound = new JA_Sound_t();
SDL_AudioSpec wavSpec;
SDL_LoadWAV(filename, &wavSpec, &sound->buffer, &sound->length);
SDL_AudioCVT cvt;
SDL_BuildAudioCVT(&cvt, wavSpec.format, wavSpec.channels, wavSpec.freq, JA_format, JA_channels, JA_freq);
cvt.len = sound->length;
cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult);
SDL_memcpy(cvt.buf, sound->buffer, sound->length);
SDL_ConvertAudio(&cvt);
SDL_FreeWAV(sound->buffer);
sound->buffer = cvt.buf;
sound->length = cvt.len_cvt;
return sound;
}
int JA_PlaySound(JA_Sound sound, const int loop) {
int channel = 0;
while (channel < JA_MAX_SIMULTANEOUS_CHANNELS && channels[channel].state != JA_CHANNEL_FREE) { channel++; }
if (channel == JA_MAX_SIMULTANEOUS_CHANNELS) channel = 0;
channels[channel].sound = sound;
channels[channel].times = loop;
channels[channel].pos = 0;
channels[channel].state = JA_CHANNEL_PLAYING;
return channel;
}
void JA_DeleteSound(JA_Sound sound) {
for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
if (channels[i].sound == sound) JA_StopChannel(i);
}
SDL_free(sound->buffer);
delete sound;
}
void JA_PauseChannel(const int channel) {
if (channel == -1) {
for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
if (channels[i].state == JA_CHANNEL_PLAYING) channels[i].state = JA_CHANNEL_PAUSED;
}
} else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
if (channels[channel].state == JA_CHANNEL_PLAYING) channels[channel].state = JA_CHANNEL_PAUSED;
}
}
void JA_ResumeChannel(const int channel) {
if (channel == -1) {
for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
if (channels[i].state == JA_CHANNEL_PAUSED) channels[i].state = JA_CHANNEL_PLAYING;
}
} else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
if (channels[channel].state == JA_CHANNEL_PAUSED) channels[channel].state = JA_CHANNEL_PLAYING;
}
}
void JA_StopChannel(const int channel) {
if (channel == -1) {
for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
channels[i].state = JA_CHANNEL_FREE;
channels[i].pos = 0;
channels[i].sound = NULL;
}
} else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
channels[channel].state = JA_CHANNEL_FREE;
channels[channel].pos = 0;
channels[channel].sound = NULL;
}
}
JA_Channel_state JA_GetChannelState(const int channel) {
if (channel < 0 || channel >= JA_MAX_SIMULTANEOUS_CHANNELS) return JA_CHANNEL_INVALID;
return channels[channel].state;
}
int JA_SetVolume(int volume) {
JA_volume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
return JA_volume;
}

29
source/jail_audio.h Normal file
View File

@@ -0,0 +1,29 @@
#pragma once
#include <SDL2/SDL.h>
enum JA_Channel_state { JA_CHANNEL_INVALID, JA_CHANNEL_FREE, JA_CHANNEL_PLAYING, JA_CHANNEL_PAUSED };
enum JA_Music_state { JA_MUSIC_INVALID, JA_MUSIC_PLAYING, JA_MUSIC_PAUSED, JA_MUSIC_STOPPED };
typedef struct JA_Sound_t *JA_Sound;
typedef struct JA_Music_t *JA_Music;
void JA_Init(const int freq, const SDL_AudioFormat format, const int channels);
JA_Music JA_LoadMusic(const char* filename);
void JA_PlayMusic(JA_Music music, const int loop = -1);
void JA_PauseMusic();
void JA_ResumeMusic();
void JA_StopMusic();
JA_Music_state JA_GetMusicState();
void JA_DeleteMusic(JA_Music music);
JA_Sound JA_NewSound(Uint8* buffer, Uint32 length);
JA_Sound JA_LoadSound(const char* filename);
int JA_PlaySound(JA_Sound sound, const int loop = 0);
void JA_PauseChannel(const int channel);
void JA_ResumeChannel(const int channel);
void JA_StopChannel(const int channel);
JA_Channel_state JA_GetChannelState(const int channel);
void JA_DeleteSound(JA_Sound sound);
int JA_SetVolume(int volume);

341
source/ltexture.cpp
View File

@@ -1,137 +1,206 @@
#include "ltexture.h"
LTexture::LTexture(SDL_Renderer *gRenderer)
{
this->gRenderer = gRenderer;
// Initialize
mTexture = NULL;
mWidth = 0;
mHeight = 0;
}
LTexture::~LTexture()
{
// Deallocate
free();
}
bool LTexture::loadFromFile(std::string path)
{
// Get rid of preexisting texture
free();
// The final texture
SDL_Texture *newTexture = NULL;
// Load image at specified path
SDL_Surface *loadedSurface = IMG_Load(path.c_str());
if (loadedSurface == NULL)
{
printf("Unable to load image %s! SDL_image Error: %s\n", path.c_str(), IMG_GetError());
}
else
{
// Color key image
SDL_SetColorKey(loadedSurface, SDL_TRUE, SDL_MapRGB(loadedSurface->format, COLOR_KEY_R, COLOR_KEY_G, COLOR_KEY_B));
// Create texture from surface pixels
newTexture = SDL_CreateTextureFromSurface(gRenderer, loadedSurface);
if (newTexture == NULL)
{
printf("Unable to create texture from %s! SDL Error: %s\n", path.c_str(), SDL_GetError());
}
else
{
// Get image dimensions
mWidth = loadedSurface->w;
mHeight = loadedSurface->h;
}
// Get rid of old loaded surface
SDL_FreeSurface(loadedSurface);
}
// Return success
mTexture = newTexture;
return mTexture != NULL;
}
bool LTexture::createBlank(int width, int height, SDL_TextureAccess access)
{
// Create uninitialized texture
mTexture = SDL_CreateTexture(gRenderer, SDL_PIXELFORMAT_RGBA8888, access, width, height);
if (mTexture == NULL)
{
printf("Unable to create blank texture! SDL Error: %s\n", SDL_GetError());
}
else
{
mWidth = width;
mHeight = height;
}
return mTexture != NULL;
}
void LTexture::free()
{
// Free texture if it exists
if (mTexture != NULL)
{
SDL_DestroyTexture(mTexture);
mTexture = NULL;
mWidth = 0;
mHeight = 0;
}
}
void LTexture::setColor(Uint8 red, Uint8 green, Uint8 blue)
{
// Modulate texture rgb
SDL_SetTextureColorMod(mTexture, red, green, blue);
}
void LTexture::setBlendMode(SDL_BlendMode blending)
{
// Set blending function
SDL_SetTextureBlendMode(mTexture, blending);
}
void LTexture::setAlpha(Uint8 alpha)
{
// Modulate texture alpha
SDL_SetTextureAlphaMod(mTexture, alpha);
}
void LTexture::render(int x, int y, SDL_Rect *clip, double angle, SDL_Point *center, SDL_RendererFlip flip)
{
// Set rendering space and render to screen
SDL_Rect renderQuad = {x, y, mWidth, mHeight};
// Set clip rendering dimensions
if (clip != NULL)
{
renderQuad.w = clip->w;
renderQuad.h = clip->h;
}
// Render to screen
SDL_RenderCopyEx(gRenderer, mTexture, clip, &renderQuad, angle, center, flip);
}
void LTexture::setAsRenderTarget()
{
// Make self render target
SDL_SetRenderTarget(gRenderer, mTexture);
}
int LTexture::getWidth()
{
return mWidth;
}
int LTexture::getHeight()
{
return mHeight;
#include "ltexture.h"
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
LTexture::LTexture(SDL_Renderer *gRenderer)
{
this->gRenderer = gRenderer;
// Initialize
mTexture = NULL;
mWidth = 0;
mHeight = 0;
}
LTexture::~LTexture()
{
// Deallocate
free();
}
bool LTexture::loadFromFile(std::string path)
{
const std::string filename = path.substr(path.find_last_of("\\/") + 1);
int req_format = STBI_rgb_alpha;
int width, height, orig_format;
unsigned char *data = stbi_load(path.c_str(), &width, &height, &orig_format, req_format);
if (data == nullptr)
{
SDL_Log("Loading image failed: %s", stbi_failure_reason());
exit(1);
}
else
{
printf("Image loaded: %s\n", filename.c_str());
}
int depth, pitch;
Uint32 pixel_format;
if (req_format == STBI_rgb)
{
depth = 24;
pitch = 3 * width; // 3 bytes por pixel * pixels per linea
pixel_format = SDL_PIXELFORMAT_RGB24;
}
else
{ // STBI_rgb_alpha (RGBA)
depth = 32;
pitch = 4 * width;
pixel_format = SDL_PIXELFORMAT_RGBA32;
}
// Limpia
free();
// La textura final
SDL_Texture *newTexture = nullptr;
// Carga la imagen desde una ruta específica
SDL_Surface *loadedSurface = SDL_CreateRGBSurfaceWithFormatFrom((void *)data, width, height, depth, pitch, pixel_format);
if (loadedSurface == nullptr)
{
printf("Unable to load image %s!\n", path.c_str());
}
else
{
// Crea la textura desde los pixels de la surface
newTexture = SDL_CreateTextureFromSurface(gRenderer, loadedSurface);
if (newTexture == nullptr)
{
printf("Unable to create texture from %s! SDL Error: %s\n", path.c_str(), SDL_GetError());
}
else
{
// Obtiene las dimensiones de la imagen
this->mWidth = loadedSurface->w;
this->mHeight = loadedSurface->h;
}
// Elimina la textura cargada
SDL_FreeSurface(loadedSurface);
}
// Return success
mTexture = newTexture;
return mTexture != nullptr;
/*
// Get rid of preexisting texture
free();
// The final texture
SDL_Texture *newTexture = NULL;
// Load image at specified path
SDL_Surface *loadedSurface = IMG_Load(path.c_str());
if (loadedSurface == NULL)
{
printf("Unable to load image %s! SDL_image Error: %s\n", path.c_str(), IMG_GetError());
}
else
{
// Color key image
SDL_SetColorKey(loadedSurface, SDL_TRUE, SDL_MapRGB(loadedSurface->format, COLOR_KEY_R, COLOR_KEY_G, COLOR_KEY_B));
// Create texture from surface pixels
newTexture = SDL_CreateTextureFromSurface(gRenderer, loadedSurface);
if (newTexture == NULL)
{
printf("Unable to create texture from %s! SDL Error: %s\n", path.c_str(), SDL_GetError());
}
else
{
// Get image dimensions
mWidth = loadedSurface->w;
mHeight = loadedSurface->h;
}
// Get rid of old loaded surface
SDL_FreeSurface(loadedSurface);
}
// Return success
mTexture = newTexture;
return mTexture != NULL;
*/
}
bool LTexture::createBlank(int width, int height, SDL_TextureAccess access)
{
// Create uninitialized texture
mTexture = SDL_CreateTexture(gRenderer, SDL_PIXELFORMAT_RGBA8888, access, width, height);
if (mTexture == NULL)
{
printf("Unable to create blank texture! SDL Error: %s\n", SDL_GetError());
}
else
{
mWidth = width;
mHeight = height;
}
return mTexture != NULL;
}
void LTexture::free()
{
// Free texture if it exists
if (mTexture != NULL)
{
SDL_DestroyTexture(mTexture);
mTexture = NULL;
mWidth = 0;
mHeight = 0;
}
}
void LTexture::setColor(Uint8 red, Uint8 green, Uint8 blue)
{
// Modulate texture rgb
SDL_SetTextureColorMod(mTexture, red, green, blue);
}
void LTexture::setBlendMode(SDL_BlendMode blending)
{
// Set blending function
SDL_SetTextureBlendMode(mTexture, blending);
}
void LTexture::setAlpha(Uint8 alpha)
{
// Modulate texture alpha
SDL_SetTextureAlphaMod(mTexture, alpha);
}
void LTexture::render(int x, int y, SDL_Rect *clip, double angle, SDL_Point *center, SDL_RendererFlip flip)
{
// Set rendering space and render to screen
SDL_Rect renderQuad = {x, y, mWidth, mHeight};
// Set clip rendering dimensions
if (clip != NULL)
{
renderQuad.w = clip->w;
renderQuad.h = clip->h;
}
// Render to screen
SDL_RenderCopyEx(gRenderer, mTexture, clip, &renderQuad, angle, center, flip);
}
void LTexture::setAsRenderTarget()
{
// Make self render target
SDL_SetRenderTarget(gRenderer, mTexture);
}
int LTexture::getWidth()
{
return mWidth;
}
int LTexture::getHeight()
{
return mHeight;
}

140
source/ltexture.h
View File

@@ -1,71 +1,71 @@
#pragma once
#include "const.h"
#include "globals.h"
#include <stdio.h>
#include <string>
#ifndef LTEXTURE_H
#define LTEXTURE_H
// Texture wrapper class
class LTexture
{
public:
// Initializes variables
LTexture(SDL_Renderer *gRenderer);
// Deallocates memory
~LTexture();
// Loads image at specified path
bool loadFromFile(std::string path);
// Creates blank texture
bool createBlank(int width, int height, SDL_TextureAccess = SDL_TEXTUREACCESS_STREAMING);
// Deallocates texture
void free();
// Set color modulation
void setColor(Uint8 red, Uint8 green, Uint8 blue);
// Set blending
void setBlendMode(SDL_BlendMode blending);
// Set alpha modulation
void setAlpha(Uint8 alpha);
// Renders texture at given point
void render(int x, int y, SDL_Rect *clip = NULL, double angle = 0.0, SDL_Point *center = NULL, SDL_RendererFlip flip = SDL_FLIP_NONE);
// Set self as render target
void setAsRenderTarget();
// Gets image dimensions
int getWidth();
int getHeight();
// Pixel manipulators
bool lockTexture();
bool unlockTexture();
void *getPixels();
void copyPixels(void *pixels);
int getPitch();
Uint32 getPixel32(unsigned int x, unsigned int y);
private:
// El renderizador de la ventana
SDL_Renderer *gRenderer = NULL;
// The actual hardware texture
SDL_Texture *mTexture;
void *mPixels;
int mPitch;
// Image dimensions
int mWidth;
int mHeight;
};
#pragma once
#include "const.h"
#include "globals.h"
#include <stdio.h>
#include <string>
#ifndef LTEXTURE_H
#define LTEXTURE_H
// Texture wrapper class
class LTexture
{
public:
// Initializes variables
LTexture(SDL_Renderer *gRenderer);
// Deallocates memory
~LTexture();
// Loads image at specified path
bool loadFromFile(std::string path);
// Creates blank texture
bool createBlank(int width, int height, SDL_TextureAccess = SDL_TEXTUREACCESS_STREAMING);
// Deallocates texture
void free();
// Set color modulation
void setColor(Uint8 red, Uint8 green, Uint8 blue);
// Set blending
void setBlendMode(SDL_BlendMode blending);
// Set alpha modulation
void setAlpha(Uint8 alpha);
// Renders texture at given point
void render(int x, int y, SDL_Rect *clip = NULL, double angle = 0.0, SDL_Point *center = NULL, SDL_RendererFlip flip = SDL_FLIP_NONE);
// Set self as render target
void setAsRenderTarget();
// Gets image dimensions
int getWidth();
int getHeight();
// Pixel manipulators
bool lockTexture();
bool unlockTexture();
void *getPixels();
void copyPixels(void *pixels);
int getPitch();
Uint32 getPixel32(unsigned int x, unsigned int y);
private:
// El renderizador de la ventana
SDL_Renderer *gRenderer = NULL;
// The actual hardware texture
SDL_Texture *mTexture;
void *mPixels;
int mPitch;
// Image dimensions
int mWidth;
int mHeight;
};
#endif

369
source/main.cpp
View File

@@ -1,196 +1,175 @@
/*
This source code copyrighted by JailDesigner (2020)
started on Castalla 15-07-2020.
Using some sample source code from Lazy Foo' Productions
*/
/*Descripción del enfoque utilizado para crear el juego.
El programa contine una serie de clases/objetos básicos: la clase sprite
permite dibujar partes de un fichero png en pantalla. La clase spriteanimated
contiene funcionalidad adicional para crear animaciones. La clase text permite
dibujar letras de un png en pantalla a partir de una cadena de texto. La clase
menu permite crear una estructura con diferentes elementos, escribirlos en
pantalla y seleccionar uno de ellos.
A continuación tenemos las clases enfocadas a la lógica del juego, la clase player
contiene la información del jugador, la clase balloon la de los enemigos y la
clase bullet para las balas que dispara el jugador. La clase background es
muy simple y sirve para pintar el fondo de la pantalla. Por ultimo, la clase
gamedirector es la que realiza toda la lógica y se encarga de hacer interactuar
al resto de objetos entre si.
El objeto gamedirector tiene tres estados: titulo, juego y pausa. Segun su estado
el bucle que recorre es distinto. En el bucle juego, el objeto gamedirector
tiene un objeto jugador, un vector con los objetos globo y un vector con los
objetos bala. Se encarga de comprobar las entradas de teclado o gamepad para
cerrar la aplicacion, saltar al estado de pausa y para mover al jugador. Recorre
el vector de globos y de balas y si tienen algun tipo asignado las gestiona.
Comprueba las colisiones entre los globos y el jugador y entre las balas y los
globos. Tiene ademas un nivel de amenaza que calcula en funcion del numero de globos
en pantalla y que se va incrementando conforme aumenta la puntuación del jugador.
Los objetos globo tienen varios contadores para alternar de un estado a otro.
En los vectores que contienen objetos, se considera activos los objetos que tienen
un tipo asociado diferente a NO_KIND
*/
#define TEST_
#include "background.h"
#include "balloon.h"
#include "bullet.h"
#include "const.h"
#include "gamedirector.h"
#include "globals.h"
#include "ltexture.h"
#include "menu.h"
#include "player.h"
#include "sprite.h"
#include "spriteanimated.h"
#include "text.h"
#include <iostream>
#include <stdio.h>
#include <string>
// La ventana donde dibujamos
SDL_Window *gWindow = NULL;
// El renderizador de la ventana
SDL_Renderer *gRenderer = NULL;
// Arranca SDL y crea la ventana
bool init();
// Carga todos los recursos
bool loadMedia();
// Libera todos los recursos y cierra SDL
void close();
// Arranca SDL y crea la ventana
bool init()
{
// Indicador de inicialización
bool success = true;
// Inicializa SDL
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_AUDIO) < 0)
{
printf("SDL could not initialize! SDL Error: %s\n", SDL_GetError());
success = false;
}
else
{
// Establece el filtro de la textura a nearest
if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "0"))
{
printf("Warning: Nearest texture filtering not enabled!");
}
// Inicializa SDL_mixer
if (Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 2048) < 0)
{
printf("SDL_mixer could not initialize! SDL_mixer Error: %s\n", Mix_GetError());
success = false;
}
// Crea la ventana
gWindow = SDL_CreateWindow("Super Popping (Like Loc) in Jailers World", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, VIEW_WIDTH, VIEW_HEIGHT, SDL_WINDOW_SHOWN);
if (gWindow == NULL)
{
printf("Window could not be created! SDL Error: %s\n", SDL_GetError());
success = false;
}
else
{
// Crea un renderizador para la ventana con vsync
gRenderer = SDL_CreateRenderer(gWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
if (gRenderer == NULL)
{
printf("Renderer could not be created! SDL Error: %s\n", SDL_GetError());
success = false;
}
else
{
// Inicializa el color de renderizado
SDL_SetRenderDrawColor(gRenderer, 0x00, 0x00, 0x00, 0xFF);
// Establece el tamaño del buffer de renderizado
SDL_RenderSetLogicalSize(gRenderer, SCREEN_WIDTH, SCREEN_HEIGHT);
// Inicializa el cargador de PNG
int imgFlags = IMG_INIT_PNG;
if (!(IMG_Init(imgFlags) & imgFlags))
{
printf("SDL_image could not initialize! SDL_image Error: %s\n", IMG_GetError());
success = false;
}
}
}
}
return success;
}
// Libera todos los recursos y cierra SDL
void close()
{
// Destruye la ventana
SDL_DestroyRenderer(gRenderer);
SDL_DestroyWindow(gWindow);
gWindow = NULL;
gRenderer = NULL;
// Sal del subsistema SDL
IMG_Quit();
SDL_Quit();
}
int main(int argc, char *args[])
{
// Arranca SDL y crea la ventana
if (!init())
{
printf("Failed to initialize!\n");
return -1;
}
else
{
{
// Crea el objeto gameDirector
GameDirector gameDirector(gRenderer);
// Inicializa el objeto gameDirector
gameDirector.init();
#ifdef TEST
gameDirector.resetBalloons();
#endif
// Mientras no se quiera salir del juego
while (!(gameDirector.getGameStatus() == GAME_STATE_QUIT))
{
switch (gameDirector.getGameStatus())
{
case GAME_STATE_TITLE:
gameDirector.runTitle();
break;
case GAME_STATE_PLAYING:
gameDirector.runGame();
break;
case GAME_STATE_PAUSED:
gameDirector.runPausedGame();
break;
}
}
}
// Libera todos los recursos y cierra SDL
close();
return 0;
}
/*
This source code copyrighted by JailDesigner (2020)
started on Castalla 15-07-2020.
Using some sample source code from Lazy Foo' Productions
*/
/*Descripción del enfoque utilizado para crear el juego.
El programa contine una serie de clases/objetos básicos: la clase sprite
permite dibujar partes de un fichero png en pantalla. La clase spriteanimated
contiene funcionalidad adicional para crear animaciones. La clase text permite
dibujar letras de un png en pantalla a partir de una cadena de texto. La clase
menu permite crear una estructura con diferentes elementos, escribirlos en
pantalla y seleccionar uno de ellos.
A continuación tenemos las clases enfocadas a la lógica del juego, la clase player
contiene la información del jugador, la clase balloon la de los enemigos y la
clase bullet para las balas que dispara el jugador. La clase background es
muy simple y sirve para pintar el fondo de la pantalla. Por ultimo, la clase
gamedirector es la que realiza toda la lógica y se encarga de hacer interactuar
al resto de objetos entre si.
El objeto gamedirector tiene tres estados: titulo, juego y pausa. Segun su estado
el bucle que recorre es distinto. En el bucle juego, el objeto gamedirector
tiene un objeto jugador, un vector con los objetos globo y un vector con los
objetos bala. Se encarga de comprobar las entradas de teclado o gamepad para
cerrar la aplicacion, saltar al estado de pausa y para mover al jugador. Recorre
el vector de globos y de balas y si tienen algun tipo asignado las gestiona.
Comprueba las colisiones entre los globos y el jugador y entre las balas y los
globos. Tiene ademas un nivel de amenaza que calcula en funcion del numero de globos
en pantalla y que se va incrementando conforme aumenta la puntuación del jugador.
Los objetos globo tienen varios contadores para alternar de un estado a otro.
En los vectores que contienen objetos, se considera activos los objetos que tienen
un tipo asociado diferente a NO_KIND
*/
#include "background.h"
#include "balloon.h"
#include "bullet.h"
#include "const.h"
#include "gamedirector.h"
#include "globals.h"
#include "ltexture.h"
#include "menu.h"
#include "player.h"
#include "sprite.h"
#include "spriteanimated.h"
#include "text.h"
#include <iostream>
#include <stdio.h>
#include <string>
// La ventana donde dibujamos
SDL_Window *gWindow = NULL;
// El renderizador de la ventana
SDL_Renderer *gRenderer = NULL;
// Arranca SDL y crea la ventana
bool init();
// Carga todos los recursos
bool loadMedia();
// Libera todos los recursos y cierra SDL
void close();
// Arranca SDL y crea la ventana
bool init()
{
// Indicador de inicialización
bool success = true;
// Inicializa SDL
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_AUDIO) < 0)
{
printf("SDL could not initialize! SDL Error: %s\n", SDL_GetError());
success = false;
}
else
{
// Establece el filtro de la textura a nearest
if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "0"))
{
printf("Warning: Nearest texture filtering not enabled!");
}
// Crea la ventana
gWindow = SDL_CreateWindow("Super Popping (Like Loc) in Jailers World", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, VIEW_WIDTH, VIEW_HEIGHT, SDL_WINDOW_SHOWN);
if (gWindow == NULL)
{
printf("Window could not be created! SDL Error: %s\n", SDL_GetError());
success = false;
}
else
{
// Crea un renderizador para la ventana con vsync
gRenderer = SDL_CreateRenderer(gWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
if (gRenderer == NULL)
{
printf("Renderer could not be created! SDL Error: %s\n", SDL_GetError());
success = false;
}
else
{
// Inicializa el color de renderizado
SDL_SetRenderDrawColor(gRenderer, 0x00, 0x00, 0x00, 0xFF);
// Establece el tamaño del buffer de renderizado
SDL_RenderSetLogicalSize(gRenderer, SCREEN_WIDTH, SCREEN_HEIGHT);
}
}
}
// Inicializa JailAudio
JA_Init(44100, AUDIO_S16, 2);
return success;
}
// Libera todos los recursos y cierra SDL
void close()
{
// Destruye la ventana
SDL_DestroyRenderer(gRenderer);
SDL_DestroyWindow(gWindow);
gWindow = NULL;
gRenderer = NULL;
// Sal del subsistema SDL
SDL_Quit();
}
int main(int argc, char *args[])
{
// Arranca SDL y crea la ventana
if (!init())
{
printf("Failed to initialize!\n");
return -1;
}
else
{
{
// Crea el objeto gameDirector
GameDirector gameDirector(gRenderer);
// Mientras no se quiera salir del juego
while (!(gameDirector.getGameStatus() == GAME_STATE_QUIT))
{
switch (gameDirector.getGameStatus())
{
case GAME_STATE_TITLE:
gameDirector.runTitle();
break;
case GAME_STATE_PLAYING:
gameDirector.runGame();
break;
case GAME_STATE_PAUSED:
gameDirector.runPausedGame();
break;
}
}
}
// Libera todos los recursos y cierra SDL
close();
return 0;
}
}

418
source/menu.cpp
View File

@@ -1,210 +1,210 @@
#include "menu.h"
// Constructor
Menu::Menu(SDL_Renderer *gRenderer)
{
this->gRenderer = gRenderer;
gMenuTexture = new LTexture(gRenderer);
// Carga los gráficos para el menu
if (!gMenuTexture->loadFromFile("media/gfx/menu.png"))
{
printf("Failed to load menu texture!\n");
}
init(0, 0, 0, MENU_BACKGROUND_SOLID);
}
// Destructor
Menu::~Menu()
{
gMenuTexture->free();
}
// Inicializador
void Menu::init(int x, int y, int offset_sprite_selector, int backgroundType)
{
// Inicia variables
mSelectorIndex = 0;
mTotalItems = 0;
mItemSelected = MENU_NO_OPTION;
mPosX = x;
mPosY = y;
mRect.x = 0;
mRect.y = 0;
mRect.w = 0;
mRect.h = 0;
mRectR = 0;
mRectG = 0;
mRectB = 0;
mBackgroundType = backgroundType;
// Sprite con los graficos del selector
mSelectorSprite.setWidth(8);
mSelectorSprite.setHeight(8);
mSelectorSprite.setPosX(0);
mSelectorSprite.setPosY(0);
mSelectorSprite.setTexture(*gMenuTexture);
mSelectorSprite.setSpriteClip(offset_sprite_selector, 0, mSelectorSprite.getWidth(), mSelectorSprite.getHeight());
// Elementos del menu
for (Uint8 i = 0; i < 10; i++)
{
mMenuItem[i].label = "";
mMenuItem[i].x = mPosX;
mMenuItem[i].y = mPosY + (i * (BLOCK + 2));
}
// Mueve el grafico del selector al elemento seleccionado
moveSelectorSprite(mSelectorIndex);
}
// Obtiene el valor de la variable
Uint8 Menu::getItemSelected()
{
return mItemSelected;
};
// Mueve el grafico del selector al elemento seleccionado
void Menu::moveSelectorSprite(int pos)
{
mSelectorSprite.setPosX(mMenuItem[pos].x - (BLOCK * 1));
mSelectorSprite.setPosY(mMenuItem[pos].y);
}
// Deja el menu apuntando al primer elemento
void Menu::resetMenu()
{
mItemSelected = MENU_NO_OPTION;
mSelectorIndex = 0;
moveSelectorSprite(mSelectorIndex);
};
// Deja el menu apuntando al siguiente elemento
void Menu::increaseSelectorIndex()
{
if (mSelectorIndex < (mTotalItems - 1))
{
++mSelectorIndex;
}
};
// Deja el menu apuntando al elemento anterior
void Menu::decreaseSelectorIndex()
{
if (mSelectorIndex > 0)
{
--mSelectorIndex;
}
};
// Comprueba la entrada (teclado, gamepad) y actua en consecuencia
void Menu::checkInput(Uint8 input)
{
switch (input)
{
case INPUT_UP:
decreaseSelectorIndex();
moveSelectorSprite(mSelectorIndex);
break;
case INPUT_DOWN:
increaseSelectorIndex();
moveSelectorSprite(mSelectorIndex);
break;
case INPUT_FIRE:
mItemSelected = mSelectorIndex;
break;
}
}
// Pinta el menu en pantalla
void Menu::render(Text &text)
{
// Render color filled quad
if (mBackgroundType == MENU_BACKGROUND_SOLID)
{
SDL_SetRenderDrawColor(gRenderer, mRectR, mRectG, mRectB, mRectA);
SDL_RenderFillRect(gRenderer, &mRect);
}
// Render text
int i = 0;
mSelectorSprite.render();
for (i = 0; i < mTotalItems; i++)
{
text.write(mMenuItem[i].x, mMenuItem[i].y, mMenuItem[i].label);
}
}
// Establece el rectangulo de fondo del menu
void Menu::setRectSize()
{
int i = 0;
int maxLength = 0;
// La altura se corresponde al numero de items mas un hueco arriba y otro abajo
mRect.h = (mTotalItems + 2) * BLOCK;
// La anchura es la de la cadena mas larga mas tres bloques, uno por la derecha
// y dos por la izquierda, uno de ellos para el selector
for (i = 0; i < mTotalItems; i++)
{
if ((int)mMenuItem[i].label.length() > maxLength)
{
maxLength = mMenuItem[i].label.length();
}
}
mRect.w = (maxLength + 3) * BLOCK;
mRect.x = mPosX - (BLOCK * 2);
mRect.y = mPosY - BLOCK;
}
// Establece el valor de la variable
void Menu::setTotalItems(int num)
{
mTotalItems = num;
}
// Establece el color del rectangulo de fondo
void Menu::setBackgroundColor(int r, int g, int b, int alpha)
{
mRectR = r;
mRectG = g;
mRectB = b;
mRectA = alpha;
}
// Centra el menu en pantalla
void Menu::centerMenuOnScreen()
{
// Actualiza el rectangulo de fondo para recalcular las dimensiones
setRectSize();
// Establece la nueva posición centrada en funcion del ancho
// de la pantalla y del ancho del rectangulo
mPosX = (SCREEN_WIDTH / 2) - (mRect.w / 2) + (BLOCK * 2);
// Reposiciona los elementos del menu
for (Uint8 i = 0; i < 10; i++)
{
mMenuItem[i].x = mPosX;
}
// Recalcula el rectangulo de fondo
setRectSize();
// Recoloca el selector
moveSelectorSprite(mSelectorIndex);
}
// Añade un item al menu
void Menu::addItem(std::string text)
{
if (mTotalItems < 10)
{
mMenuItem[mTotalItems].label = text;
setTotalItems(mTotalItems + 1);
setRectSize();
}
#include "menu.h"
// Constructor
Menu::Menu(SDL_Renderer *gRenderer)
{
this->gRenderer = gRenderer;
gMenuTexture = new LTexture(gRenderer);
// Carga los gráficos para el menu
if (!gMenuTexture->loadFromFile("media/gfx/menu.png"))
{
printf("Failed to load menu texture!\n");
}
//init(0, 0, 0, MENU_BACKGROUND_SOLID);
}
// Destructor
Menu::~Menu()
{
gMenuTexture->free();
}
// Inicializador
void Menu::init(int x, int y, int offset_sprite_selector, int backgroundType)
{
// Inicia variables
mSelectorIndex = 0;
mTotalItems = 0;
mItemSelected = MENU_NO_OPTION;
mPosX = x;
mPosY = y;
mRect.x = 0;
mRect.y = 0;
mRect.w = 0;
mRect.h = 0;
mRectR = 0;
mRectG = 0;
mRectB = 0;
mBackgroundType = backgroundType;
// Sprite con los graficos del selector
mSelectorSprite.setWidth(8);
mSelectorSprite.setHeight(8);
mSelectorSprite.setPosX(0);
mSelectorSprite.setPosY(0);
mSelectorSprite.setTexture(*gMenuTexture);
mSelectorSprite.setSpriteClip(offset_sprite_selector, 0, mSelectorSprite.getWidth(), mSelectorSprite.getHeight());
// Elementos del menu
for (Uint8 i = 0; i < 10; i++)
{
mMenuItem[i].x = mPosX;
mMenuItem[i].y = mPosY + (i * (BLOCK + 2));
mMenuItem[i].label = "s";
}
// Mueve el grafico del selector al elemento seleccionado
moveSelectorSprite(mSelectorIndex);
}
// Obtiene el valor de la variable
Uint8 Menu::getItemSelected()
{
return mItemSelected;
};
// Mueve el grafico del selector al elemento seleccionado
void Menu::moveSelectorSprite(int pos)
{
mSelectorSprite.setPosX(mMenuItem[pos].x - (BLOCK * 1));
mSelectorSprite.setPosY(mMenuItem[pos].y);
}
// Deja el menu apuntando al primer elemento
void Menu::resetMenu()
{
mItemSelected = MENU_NO_OPTION;
mSelectorIndex = 0;
moveSelectorSprite(mSelectorIndex);
};
// Deja el menu apuntando al siguiente elemento
void Menu::increaseSelectorIndex()
{
if (mSelectorIndex < (mTotalItems - 1))
{
++mSelectorIndex;
}
};
// Deja el menu apuntando al elemento anterior
void Menu::decreaseSelectorIndex()
{
if (mSelectorIndex > 0)
{
--mSelectorIndex;
}
};
// Comprueba la entrada (teclado, gamepad) y actua en consecuencia
void Menu::checkInput(Uint8 input)
{
switch (input)
{
case INPUT_UP:
decreaseSelectorIndex();
moveSelectorSprite(mSelectorIndex);
break;
case INPUT_DOWN:
increaseSelectorIndex();
moveSelectorSprite(mSelectorIndex);
break;
case INPUT_FIRE:
mItemSelected = mSelectorIndex;
break;
}
}
// Pinta el menu en pantalla
void Menu::render(Text &text)
{
// Render color filled quad
if (mBackgroundType == MENU_BACKGROUND_SOLID)
{
SDL_SetRenderDrawColor(gRenderer, mRectR, mRectG, mRectB, mRectA);
SDL_RenderFillRect(gRenderer, &mRect);
}
// Render text
int i = 0;
mSelectorSprite.render();
for (i = 0; i < mTotalItems; i++)
{
text.write(mMenuItem[i].x, mMenuItem[i].y, mMenuItem[i].label);
}
}
// Establece el rectangulo de fondo del menu
void Menu::setRectSize()
{
int i = 0;
int maxLength = 0;
// La altura se corresponde al numero de items mas un hueco arriba y otro abajo
mRect.h = (mTotalItems + 2) * BLOCK;
// La anchura es la de la cadena mas larga mas tres bloques, uno por la derecha
// y dos por la izquierda, uno de ellos para el selector
for (i = 0; i < mTotalItems; i++)
{
if ((int)mMenuItem[i].label.length() > maxLength)
{
maxLength = mMenuItem[i].label.length();
}
}
mRect.w = (maxLength + 3) * BLOCK;
mRect.x = mPosX - (BLOCK * 2);
mRect.y = mPosY - BLOCK;
}
// Establece el valor de la variable
void Menu::setTotalItems(int num)
{
mTotalItems = num;
}
// Establece el color del rectangulo de fondo
void Menu::setBackgroundColor(int r, int g, int b, int alpha)
{
mRectR = r;
mRectG = g;
mRectB = b;
mRectA = alpha;
}
// Centra el menu en pantalla
void Menu::centerMenuOnScreen()
{
// Actualiza el rectangulo de fondo para recalcular las dimensiones
setRectSize();
// Establece la nueva posición centrada en funcion del ancho
// de la pantalla y del ancho del rectangulo
mPosX = (SCREEN_WIDTH / 2) - (mRect.w / 2) + (BLOCK * 2);
// Reposiciona los elementos del menu
for (Uint8 i = 0; i < 10; i++)
{
mMenuItem[i].x = mPosX;
}
// Recalcula el rectangulo de fondo
setRectSize();
// Recoloca el selector
moveSelectorSprite(mSelectorIndex);
}
// Añade un item al menu
void Menu::addItem(std::string text)
{
if (mTotalItems < 10)
{
mMenuItem[mTotalItems].label = text;
setTotalItems(mTotalItems + 1);
setRectSize();
}
}

200
source/menu.h
View File

@@ -1,101 +1,101 @@
#pragma once
#include "sprite.h"
#include "const.h"
#include "globals.h"
#include "text.h"
#ifndef MENU_H
#define MENU_H
// Clase menu
class Menu
{
public:
// Constructor
Menu(SDL_Renderer *gRenderer);
// Destructor
~Menu();
// Inicializador
void init(int x, int y, int offset_sprite_selector, int backgroundType);
// Obtiene el valor de la variable
Uint8 getItemSelected();
// Mueve el grafico del selector al elemento seleccionado
void moveSelectorSprite(int pos);
// Deja el menu apuntando al primer elemento
void resetMenu();
// Deja el menu apuntando al siguiente elemento
void increaseSelectorIndex();
// Deja el menu apuntando al elemento anterior
void decreaseSelectorIndex();
// Comprueba la entrada (teclado, gamepad) y actua en consecuencia
void checkInput(Uint8 input);
// Pinta el menu en pantalla
void render(Text &text);
// Establece el rectangulo de fondo del menu
void setRectSize();
// Establece el valor de la variable
void setTotalItems(int num);
// Establece el color del rectangulo de fondo
void setBackgroundColor(int r, int g, int b, int alpha);
// Centra el menu en pantalla
void centerMenuOnScreen();
// Añade un item al menu
void addItem(std::string text);
private:
// El renderizador de la ventana
SDL_Renderer *gRenderer;
LTexture *gMenuTexture;
// Posicion X/Y del texto del primer elemento del menu
int mPosX;
int mPosY;
// Elemento del menu que tiene el foco
Uint8 mSelectorIndex;
// Numero de items del menu
Uint8 mTotalItems;
// Item del menu que ha sido seleccionado
Uint8 mItemSelected;
// Tipo de fondo para el menu
Uint8 mBackgroundType;
// Sprite con los graficos del selector
Sprite mSelectorSprite;
// Rectangulo y colores para el fondo del menu
SDL_Rect mRect;
Uint8 mRectR; // Rojo
Uint8 mRectG; // Verde
Uint8 mRectB; // Azul
Uint8 mRectA; // Alfa o transparencia
// Estructura para cada elemento del menu
struct MenuItem
{
std::string label;
int x;
int y;
} mMenuItem[10];
};
#pragma once
#include "sprite.h"
#include "const.h"
#include "globals.h"
#include "text.h"
#ifndef MENU_H
#define MENU_H
// Clase menu
class Menu
{
public:
// Constructor
Menu(SDL_Renderer *gRenderer);
// Destructor
~Menu();
// Inicializador
void init(int x, int y, int offset_sprite_selector, int backgroundType);
// Obtiene el valor de la variable
Uint8 getItemSelected();
// Mueve el grafico del selector al elemento seleccionado
void moveSelectorSprite(int pos);
// Deja el menu apuntando al primer elemento
void resetMenu();
// Deja el menu apuntando al siguiente elemento
void increaseSelectorIndex();
// Deja el menu apuntando al elemento anterior
void decreaseSelectorIndex();
// Comprueba la entrada (teclado, gamepad) y actua en consecuencia
void checkInput(Uint8 input);
// Pinta el menu en pantalla
void render(Text &text);
// Establece el rectangulo de fondo del menu
void setRectSize();
// Establece el valor de la variable
void setTotalItems(int num);
// Establece el color del rectangulo de fondo
void setBackgroundColor(int r, int g, int b, int alpha);
// Centra el menu en pantalla
void centerMenuOnScreen();
// Añade un item al menu
void addItem(std::string text);
private:
// El renderizador de la ventana
SDL_Renderer *gRenderer;
LTexture *gMenuTexture;
// Posicion X/Y del texto del primer elemento del menu
int mPosX;
int mPosY;
// Elemento del menu que tiene el foco
Uint8 mSelectorIndex;
// Numero de items del menu
Uint8 mTotalItems;
// Item del menu que ha sido seleccionado
Uint8 mItemSelected;
// Tipo de fondo para el menu
Uint8 mBackgroundType;
// Sprite con los graficos del selector
Sprite mSelectorSprite;
// Rectangulo y colores para el fondo del menu
SDL_Rect mRect;
Uint8 mRectR; // Rojo
Uint8 mRectG; // Verde
Uint8 mRectB; // Azul
Uint8 mRectA; // Alfa o transparencia
// Estructura para cada elemento del menu
struct MenuItem
{
std::string label;
int x;
int y;
} mMenuItem[10];
};
#endif

534
source/player.cpp
View File

@@ -1,268 +1,268 @@
#include "player.h"
// Constructor
Player::Player(SDL_Renderer *gRenderer)
{
this->gRenderer = gRenderer;
gPlayerTexture = new LTexture(gRenderer);
// Carga los gráficos del jugador
if (!gPlayerTexture->loadFromFile("media/gfx/player.png"))
{
printf("Failed to load player texture!\n");
}
init();
}
// Destructor
Player::~Player()
{
gPlayerTexture->free();
}
// Iniciador
void Player::init()
{
// Establece la altura y el ancho del jugador
mWidth = 3 * BLOCK;
mHeight = 3 * BLOCK;
// Establece la posición inicial del jugador
mPosX = PLAY_AREA_LEFT + (PLAY_AREA_WIDTH / 2) - (mWidth / 2);
mPosY = PLAY_AREA_BOTTOM - mHeight;
// Establece el tamaño del circulo de colisión
mCollider.r = 7;
// Actualiza la posición del circulo de colisión
shiftColliders();
// Establece la velocidad inicial
mVelX = 0;
mVelY = 0;
// Establece la velocidad base
mBaseSpeed = 1.5;
// Establece el numero inicial de vidas
mStartingLives = 3;
mLives = mStartingLives;
// Establece la puntuación inicial
mScore = 0;
// Inicia el contador
mCooldown = 10;
// Inicia el sprite
mSprite.init();
// Set width and height of the player sprite
mSprite.setWidth(mWidth);
mSprite.setHeight(mHeight);
// Set sprite position
mSprite.setPosX(mPosX);
mSprite.setPosY(mPosY);
// Set sprite sheet
mSprite.setTexture(*gPlayerTexture);
// Set status
mStatus = PLAYER_STATE_STOPPED;
// Initialize animation variables
mSprite.setCurrentFrame(0);
mSprite.setAnimationCounter(0);
mSprite.setAnimationNumFrames(PLAYER_STATE_STOPPED, 1);
mSprite.setAnimationNumFrames(PLAYER_STATE_WALKING_LEFT, 4);
mSprite.setAnimationNumFrames(PLAYER_STATE_WALKING_RIGHT, 4);
mSprite.setAnimationSpeed(PLAYER_STATE_STOPPED, 10);
mSprite.setAnimationSpeed(PLAYER_STATE_WALKING_LEFT, 5);
mSprite.setAnimationSpeed(PLAYER_STATE_WALKING_RIGHT, 5);
// Set animation clips
mSprite.setAnimationFrames(PLAYER_STATE_WALKING_LEFT, 0, mSprite.getWidth() * 0, mSprite.getWidth() * 0, mSprite.getWidth(), mSprite.getHeight());
mSprite.setAnimationFrames(PLAYER_STATE_WALKING_LEFT, 1, mSprite.getWidth() * 1, mSprite.getWidth() * 0, mSprite.getWidth(), mSprite.getHeight());
mSprite.setAnimationFrames(PLAYER_STATE_WALKING_LEFT, 2, mSprite.getWidth() * 2, mSprite.getWidth() * 0, mSprite.getWidth(), mSprite.getHeight());
mSprite.setAnimationFrames(PLAYER_STATE_WALKING_LEFT, 3, mSprite.getWidth() * 3, mSprite.getWidth() * 0, mSprite.getWidth(), mSprite.getHeight());
mSprite.setAnimationFrames(PLAYER_STATE_WALKING_RIGHT, 0, mSprite.getWidth() * 0, mSprite.getHeight() * 1, mSprite.getWidth(), mSprite.getHeight());
mSprite.setAnimationFrames(PLAYER_STATE_WALKING_RIGHT, 1, mSprite.getWidth() * 1, mSprite.getHeight() * 1, mSprite.getWidth(), mSprite.getHeight());
mSprite.setAnimationFrames(PLAYER_STATE_WALKING_RIGHT, 2, mSprite.getWidth() * 2, mSprite.getHeight() * 1, mSprite.getWidth(), mSprite.getHeight());
mSprite.setAnimationFrames(PLAYER_STATE_WALKING_RIGHT, 3, mSprite.getWidth() * 3, mSprite.getHeight() * 1, mSprite.getWidth(), mSprite.getHeight());
mSprite.setAnimationFrames(PLAYER_STATE_STOPPED, 0, mSprite.getWidth() * 0, mSprite.getHeight() * 2, mSprite.getWidth(), mSprite.getHeight());
// Set window for sprite sheet
mSprite.setSpriteClip(mSprite.getAnimationClip(PLAYER_STATE_STOPPED, 0));
}
// Comprueba el teclado y actua en consecuencia
void Player::checkInput(Uint8 input)
{
switch (input)
{
case INPUT_LEFT:
mVelX = -mBaseSpeed;
setStatus(PLAYER_STATE_WALKING_LEFT);
break;
case INPUT_RIGHT:
mVelX = mBaseSpeed;
setStatus(PLAYER_STATE_WALKING_RIGHT);
break;
default:
mVelX = 0;
setStatus(PLAYER_STATE_STOPPED);
break;
}
}
// Mueve el jugador a la posición y animación que le corresponde
void Player::move()
{
// Move the player left or right
mPosX += mVelX;
// If the player went too far to the left or right
if ((mPosX < PLAY_AREA_LEFT) || (mPosX + mWidth > PLAY_AREA_RIGHT))
{
// Move back
mPosX -= mVelX;
}
// Move the player up or down
mPosY += mVelY;
// If the player went too far up or down
if ((mPosY < PLAY_AREA_TOP) || (mPosY + mHeight > PLAY_AREA_BOTTOM))
{
// Move back
mPosY -= mVelY;
}
// Update sprite position
mSprite.setPosX(getPosX());
mSprite.setPosY(mPosY);
}
// Pinta el jugador en pantalla
void Player::render()
{
mSprite.render();
}
// Establece el estado del jugador
void Player::setStatus(int status)
{
// Si cambiamos de estado, reiniciamos la animación
if (mStatus != status)
{
mStatus = status;
mSprite.setCurrentFrame(0);
}
}
// Establece la animación correspondiente al estado
void Player::setAnimation()
{
mSprite.animate(mStatus);
}
// Obtiene el valor de la variable
int Player::getPosX()
{
return int(mPosX);
}
// Obtiene el valor de la variable
int Player::getPosY()
{
return mPosY;
}
// Obtiene el valor de la variable
int Player::getWidth()
{
return mWidth;
}
// Obtiene el valor de la variable
int Player::getHeight()
{
return mHeight;
}
// Indica si el jugador puede disparar
bool Player::canFire()
{
// Si el contador a llegado a cero, podemos disparar. En caso contrario decrementamos el contador
if (mCooldown > 0)
{
return false;
}
else
{
return true;
}
}
// Establece el valor de la variable
void Player::setFireCooldown(int time)
{
mCooldown = time;
}
// Actualiza el valor de la variable
void Player::updateCooldown()
{
if (mCooldown > 0)
{
--mCooldown;
}
}
// Actualiza al jugador a su posicion, animación y controla los contadores
void Player::update()
{
move();
setAnimation();
shiftColliders();
updateCooldown();
}
// Obtiene la puntuación del jugador
int Player::getScore()
{
return mScore;
}
// Establece la puntuación del jugador
void Player::setScore(int score)
{
mScore = score;
}
// Añade a la puntuación del jugador
void Player::addScore(int score)
{
mScore += score;
}
// Obtiene el circulo de colisión
Circle &Player::getCollider()
{
return mCollider;
}
// Actualiza el circulo de colisión a la posición del jugador
void Player::shiftColliders()
{
// Align collider to center of player
mCollider.x = mPosX + (mWidth / 2);
mCollider.y = mPosY + (mHeight / 2);
#include "player.h"
// Constructor
Player::Player(SDL_Renderer *gRenderer)
{
this->gRenderer = gRenderer;
gPlayerTexture = new LTexture(gRenderer);
// Carga los gráficos del jugador
if (!gPlayerTexture->loadFromFile("media/gfx/player.png"))
{
printf("Failed to load player texture!\n");
}
init();
}
// Destructor
Player::~Player()
{
gPlayerTexture->free();
}
// Iniciador
void Player::init()
{
// Establece la altura y el ancho del jugador
mWidth = 3 * BLOCK;
mHeight = 3 * BLOCK;
// Establece la posición inicial del jugador
mPosX = PLAY_AREA_LEFT + (PLAY_AREA_WIDTH / 2) - (mWidth / 2);
mPosY = PLAY_AREA_BOTTOM - mHeight;
// Establece el tamaño del circulo de colisión
mCollider.r = 7;
// Actualiza la posición del circulo de colisión
shiftColliders();
// Establece la velocidad inicial
mVelX = 0;
mVelY = 0;
// Establece la velocidad base
mBaseSpeed = 1.5;
// Establece el numero inicial de vidas
mStartingLives = 3;
mLives = mStartingLives;
// Establece la puntuación inicial
mScore = 0;
// Inicia el contador
mCooldown = 10;
// Inicia el sprite
mSprite.init();
// Set width and height of the player sprite
mSprite.setWidth(mWidth);
mSprite.setHeight(mHeight);
// Set sprite position
mSprite.setPosX(mPosX);
mSprite.setPosY(mPosY);
// Set sprite sheet
mSprite.setTexture(*gPlayerTexture);
// Set status
mStatus = PLAYER_STATE_STOPPED;
// Initialize animation variables
mSprite.setCurrentFrame(0);
mSprite.setAnimationCounter(0);
mSprite.setAnimationNumFrames(PLAYER_STATE_STOPPED, 1);
mSprite.setAnimationNumFrames(PLAYER_STATE_WALKING_LEFT, 4);
mSprite.setAnimationNumFrames(PLAYER_STATE_WALKING_RIGHT, 4);
mSprite.setAnimationSpeed(PLAYER_STATE_STOPPED, 10);
mSprite.setAnimationSpeed(PLAYER_STATE_WALKING_LEFT, 5);
mSprite.setAnimationSpeed(PLAYER_STATE_WALKING_RIGHT, 5);
// Set animation clips
mSprite.setAnimationFrames(PLAYER_STATE_WALKING_LEFT, 0, mSprite.getWidth() * 0, mSprite.getWidth() * 0, mSprite.getWidth(), mSprite.getHeight());
mSprite.setAnimationFrames(PLAYER_STATE_WALKING_LEFT, 1, mSprite.getWidth() * 1, mSprite.getWidth() * 0, mSprite.getWidth(), mSprite.getHeight());
mSprite.setAnimationFrames(PLAYER_STATE_WALKING_LEFT, 2, mSprite.getWidth() * 2, mSprite.getWidth() * 0, mSprite.getWidth(), mSprite.getHeight());
mSprite.setAnimationFrames(PLAYER_STATE_WALKING_LEFT, 3, mSprite.getWidth() * 3, mSprite.getWidth() * 0, mSprite.getWidth(), mSprite.getHeight());
mSprite.setAnimationFrames(PLAYER_STATE_WALKING_RIGHT, 0, mSprite.getWidth() * 0, mSprite.getHeight() * 1, mSprite.getWidth(), mSprite.getHeight());
mSprite.setAnimationFrames(PLAYER_STATE_WALKING_RIGHT, 1, mSprite.getWidth() * 1, mSprite.getHeight() * 1, mSprite.getWidth(), mSprite.getHeight());
mSprite.setAnimationFrames(PLAYER_STATE_WALKING_RIGHT, 2, mSprite.getWidth() * 2, mSprite.getHeight() * 1, mSprite.getWidth(), mSprite.getHeight());
mSprite.setAnimationFrames(PLAYER_STATE_WALKING_RIGHT, 3, mSprite.getWidth() * 3, mSprite.getHeight() * 1, mSprite.getWidth(), mSprite.getHeight());
mSprite.setAnimationFrames(PLAYER_STATE_STOPPED, 0, mSprite.getWidth() * 0, mSprite.getHeight() * 2, mSprite.getWidth(), mSprite.getHeight());
// Set window for sprite sheet
mSprite.setSpriteClip(mSprite.getAnimationClip(PLAYER_STATE_STOPPED, 0));
}
// Comprueba el teclado y actua en consecuencia
void Player::checkInput(Uint8 input)
{
switch (input)
{
case INPUT_LEFT:
mVelX = -mBaseSpeed;
setStatus(PLAYER_STATE_WALKING_LEFT);
break;
case INPUT_RIGHT:
mVelX = mBaseSpeed;
setStatus(PLAYER_STATE_WALKING_RIGHT);
break;
default:
mVelX = 0;
setStatus(PLAYER_STATE_STOPPED);
break;
}
}
// Mueve el jugador a la posición y animación que le corresponde
void Player::move()
{
// Move the player left or right
mPosX += mVelX;
// If the player went too far to the left or right
if ((mPosX < PLAY_AREA_LEFT) || (mPosX + mWidth > PLAY_AREA_RIGHT))
{
// Move back
mPosX -= mVelX;
}
// Move the player up or down
mPosY += mVelY;
// If the player went too far up or down
if ((mPosY < PLAY_AREA_TOP) || (mPosY + mHeight > PLAY_AREA_BOTTOM))
{
// Move back
mPosY -= mVelY;
}
// Update sprite position
mSprite.setPosX(getPosX());
mSprite.setPosY(mPosY);
}
// Pinta el jugador en pantalla
void Player::render()
{
mSprite.render();
}
// Establece el estado del jugador
void Player::setStatus(int status)
{
// Si cambiamos de estado, reiniciamos la animación
if (mStatus != status)
{
mStatus = status;
mSprite.setCurrentFrame(0);
}
}
// Establece la animación correspondiente al estado
void Player::setAnimation()
{
mSprite.animate(mStatus);
}
// Obtiene el valor de la variable
int Player::getPosX()
{
return int(mPosX);
}
// Obtiene el valor de la variable
int Player::getPosY()
{
return mPosY;
}
// Obtiene el valor de la variable
int Player::getWidth()
{
return mWidth;
}
// Obtiene el valor de la variable
int Player::getHeight()
{
return mHeight;
}
// Indica si el jugador puede disparar
bool Player::canFire()
{
// Si el contador a llegado a cero, podemos disparar. En caso contrario decrementamos el contador
if (mCooldown > 0)
{
return false;
}
else
{
return true;
}
}
// Establece el valor de la variable
void Player::setFireCooldown(int time)
{
mCooldown = time;
}
// Actualiza el valor de la variable
void Player::updateCooldown()
{
if (mCooldown > 0)
{
--mCooldown;
}
}
// Actualiza al jugador a su posicion, animación y controla los contadores
void Player::update()
{
move();
setAnimation();
shiftColliders();
updateCooldown();
}
// Obtiene la puntuación del jugador
int Player::getScore()
{
return mScore;
}
// Establece la puntuación del jugador
void Player::setScore(int score)
{
mScore = score;
}
// Añade a la puntuación del jugador
void Player::addScore(int score)
{
mScore += score;
}
// Obtiene el circulo de colisión
Circle &Player::getCollider()
{
return mCollider;
}
// Actualiza el circulo de colisión a la posición del jugador
void Player::shiftColliders()
{
// Align collider to center of player
mCollider.x = mPosX + (mWidth / 2);
mCollider.y = mPosY + (mHeight / 2);
}

238
source/player.h
View File

@@ -1,120 +1,120 @@
#pragma once
#include "spriteanimated.h"
#include "const.h"
#include "globals.h"
#ifndef PLAYER_H
#define PLAYER_H
// The player
class Player
{
public:
// Constructor
Player(SDL_Renderer *gRenderer);
// DEstructor
~Player();
// Iniciador
void init();
// Comprueba la entrada (teclado, gamepad) y actua en consecuencia
void checkInput(Uint8 input);
// Mueve el jugador a la posición y animación que le corresponde
void move();
// Pinta el jugador en pantalla
void render();
// Establece el estado del jugador
void setStatus(int status);
// Establece la animación correspondiente al estado
void setAnimation();
// Obtiene el valor de la variable
int getPosX();
// Obtiene el valor de la variable
int getPosY();
// Obtiene el valor de la variable
int getWidth();
// Obtiene el valor de la variable
int getHeight();
// Indica si el jugador puede disparar
bool canFire();
// Establece el valor de la variable
void setFireCooldown(int time);
// Actualiza el valor de la variable
void updateCooldown();
// Actualiza al jugador a su posicion, animación y controla los contadores
void update();
// Obtiene la puntuación del jugador
int getScore();
// Establece la puntuación del jugador
void setScore(int score);
// Añade a la puntuación del jugador
void addScore(int score);
// Obtiene el circulo de colisión
Circle &getCollider();
private:
// El renderizador de la ventana
SDL_Renderer *gRenderer;
LTexture *gPlayerTexture;
// Posición X, Y del jugador
float mPosX;
int mPosY;
// Altura y anchura del jugador
Uint8 mWidth;
Uint8 mHeight;
// Velocidad X, Y del jugador
float mVelX;
int mVelY;
// Velocidad base del jugador
float mBaseSpeed;
// Contador durante el cual no puede disparar
int mCooldown;
// Vidas actuales del jugador
Uint8 mLives;
// Vidas iniciales del jugador
Uint8 mStartingLives;
// Puntos del jugador
int mScore;
// Estado del jugador
Uint8 mStatus;
// Sprite para dibujar al jugador en pantalla
SpriteAnimated mSprite;
// Circulo de colisión del jugador
Circle mCollider;
// Actualiza el circulo de colisión a la posición del jugador
void shiftColliders();
};
#pragma once
#include "spriteanimated.h"
#include "const.h"
#include "globals.h"
#ifndef PLAYER_H
#define PLAYER_H
// The player
class Player
{
public:
// Constructor
Player(SDL_Renderer *gRenderer);
// DEstructor
~Player();
// Iniciador
void init();
// Comprueba la entrada (teclado, gamepad) y actua en consecuencia
void checkInput(Uint8 input);
// Mueve el jugador a la posición y animación que le corresponde
void move();
// Pinta el jugador en pantalla
void render();
// Establece el estado del jugador
void setStatus(int status);
// Establece la animación correspondiente al estado
void setAnimation();
// Obtiene el valor de la variable
int getPosX();
// Obtiene el valor de la variable
int getPosY();
// Obtiene el valor de la variable
int getWidth();
// Obtiene el valor de la variable
int getHeight();
// Indica si el jugador puede disparar
bool canFire();
// Establece el valor de la variable
void setFireCooldown(int time);
// Actualiza el valor de la variable
void updateCooldown();
// Actualiza al jugador a su posicion, animación y controla los contadores
void update();
// Obtiene la puntuación del jugador
int getScore();
// Establece la puntuación del jugador
void setScore(int score);
// Añade a la puntuación del jugador
void addScore(int score);
// Obtiene el circulo de colisión
Circle &getCollider();
private:
// El renderizador de la ventana
SDL_Renderer *gRenderer;
LTexture *gPlayerTexture;
// Posición X, Y del jugador
float mPosX;
int mPosY;
// Altura y anchura del jugador
Uint8 mWidth;
Uint8 mHeight;
// Velocidad X, Y del jugador
float mVelX;
int mVelY;
// Velocidad base del jugador
float mBaseSpeed;
// Contador durante el cual no puede disparar
int mCooldown;
// Vidas actuales del jugador
Uint8 mLives;
// Vidas iniciales del jugador
Uint8 mStartingLives;
// Puntos del jugador
int mScore;
// Estado del jugador
Uint8 mStatus;
// Sprite para dibujar al jugador en pantalla
SpriteAnimated mSprite;
// Circulo de colisión del jugador
Circle mCollider;
// Actualiza el circulo de colisión a la posición del jugador
void shiftColliders();
};
#endif

174
source/sprite.cpp
View File

@@ -1,88 +1,88 @@
#include "sprite.h"
void Sprite::render()
{
// Muestra el sprite por pantalla
mTexture->render(mPosX, mPosY, &mSpriteClip);
}
// Obten el valor de la variable
int Sprite::getPosX()
{
return mPosX;
}
// Obten el valor de la variable
int Sprite::getPosY()
{
return mPosY;
}
// Obten el valor de la variable
int Sprite::getWidth()
{
return mWidth;
}
// Obten el valor de la variable
int Sprite::getHeight()
{
return mHeight;
}
// Establece el valor de la variable
void Sprite::setPosX(int x)
{
mPosX = x;
}
// Establece el valor de la variable
void Sprite::setPosY(int y)
{
mPosY = y;
}
// Establece el valor de la variable
void Sprite::setWidth(int w)
{
mWidth = w;
}
// Establece el valor de la variable
void Sprite::setHeight(int h)
{
mHeight = h;
}
// Obten el valor de la variable
SDL_Rect Sprite::getSpriteClip()
{
return mSpriteClip;
}
// Establece el valor de la variable
void Sprite::setSpriteClip(SDL_Rect rect)
{
mSpriteClip = rect;
}
// Establece el valor de la variable
void Sprite::setSpriteClip(int x, int y, int w, int h)
{
mSpriteClip.x = x;
mSpriteClip.y = y;
mSpriteClip.w = w;
mSpriteClip.h = h;
}
// Obten el valor de la variable
LTexture *Sprite::getTexture()
{
return mTexture;
}
// Establece el valor de la variable
void Sprite::setTexture(LTexture &texture)
{
mTexture = &texture;
#include "sprite.h"
void Sprite::render()
{
// Muestra el sprite por pantalla
mTexture->render(mPosX, mPosY, &mSpriteClip);
}
// Obten el valor de la variable
int Sprite::getPosX()
{
return mPosX;
}
// Obten el valor de la variable
int Sprite::getPosY()
{
return mPosY;
}
// Obten el valor de la variable
int Sprite::getWidth()
{
return mWidth;
}
// Obten el valor de la variable
int Sprite::getHeight()
{
return mHeight;
}
// Establece el valor de la variable
void Sprite::setPosX(int x)
{
mPosX = x;
}
// Establece el valor de la variable
void Sprite::setPosY(int y)
{
mPosY = y;
}
// Establece el valor de la variable
void Sprite::setWidth(int w)
{
mWidth = w;
}
// Establece el valor de la variable
void Sprite::setHeight(int h)
{
mHeight = h;
}
// Obten el valor de la variable
SDL_Rect Sprite::getSpriteClip()
{
return mSpriteClip;
}
// Establece el valor de la variable
void Sprite::setSpriteClip(SDL_Rect rect)
{
mSpriteClip = rect;
}
// Establece el valor de la variable
void Sprite::setSpriteClip(int x, int y, int w, int h)
{
mSpriteClip.x = x;
mSpriteClip.y = y;
mSpriteClip.w = w;
mSpriteClip.h = h;
}
// Obten el valor de la variable
LTexture *Sprite::getTexture()
{
return mTexture;
}
// Establece el valor de la variable
void Sprite::setTexture(LTexture &texture)
{
mTexture = &texture;
}

138
source/sprite.h
View File

@@ -1,70 +1,70 @@
#pragma once
#include "ltexture.h"
#ifndef SPRITE_H
#define SPRITE_H
// Clase sprite
class Sprite
{
public:
// Muestra el sprite por pantalla
void render();
// Obten el valor de la variable
int getPosX();
// Obten el valor de la variable
int getPosY();
// Obten el valor de la variable
int getWidth();
// Obten el valor de la variable
int getHeight();
// Establece el valor de la variable
void setPosX(int x);
// Establece el valor de la variable
void setPosY(int y);
// Establece el valor de la variable
void setWidth(int w);
// Establece el valor de la variable
void setHeight(int h);
// Obten el valor de la variable
SDL_Rect getSpriteClip();
// Establece el valor de la variable
void setSpriteClip(SDL_Rect rect);
// Establece el valor de la variable
void setSpriteClip(int x, int y, int w, int h);
// Obten el valor de la variable
LTexture *getTexture();
// Establece el valor de la variable
void setTexture(LTexture &texture);
private:
// Posición X,Y donde dibujar el sprite
int mPosX;
int mPosY;
// Alto y ancho del sprite
Uint16 mWidth;
Uint16 mHeight;
// Textura donde estan todos los dibujos del sprite
LTexture *mTexture;
// Rectangulo de la textura que se dibujará en pantalla
SDL_Rect mSpriteClip;
};
#pragma once
#include "ltexture.h"
#ifndef SPRITE_H
#define SPRITE_H
// Clase sprite
class Sprite
{
public:
// Muestra el sprite por pantalla
void render();
// Obten el valor de la variable
int getPosX();
// Obten el valor de la variable
int getPosY();
// Obten el valor de la variable
int getWidth();
// Obten el valor de la variable
int getHeight();
// Establece el valor de la variable
void setPosX(int x);
// Establece el valor de la variable
void setPosY(int y);
// Establece el valor de la variable
void setWidth(int w);
// Establece el valor de la variable
void setHeight(int h);
// Obten el valor de la variable
SDL_Rect getSpriteClip();
// Establece el valor de la variable
void setSpriteClip(SDL_Rect rect);
// Establece el valor de la variable
void setSpriteClip(int x, int y, int w, int h);
// Obten el valor de la variable
LTexture *getTexture();
// Establece el valor de la variable
void setTexture(LTexture &texture);
private:
// Posición X,Y donde dibujar el sprite
int mPosX;
int mPosY;
// Alto y ancho del sprite
Uint16 mWidth;
Uint16 mHeight;
// Textura donde estan todos los dibujos del sprite
LTexture *mTexture;
// Rectangulo de la textura que se dibujará en pantalla
SDL_Rect mSpriteClip;
};
#endif

172
source/spriteanimated.cpp
View File

@@ -1,87 +1,87 @@
#include "spriteanimated.h"
// Constructor
SpriteAnimated::SpriteAnimated()
{
init();
}
// Iniciador
void SpriteAnimated::init()
{
for (Uint8 i = 0; i < 20; i++)
{
mAnimation[i].numFrames = 0;
mAnimation[i].speed = 0;
for (Uint8 j = 0; i < 20; i++)
{
mAnimation[i].frames[j].x = 0;
mAnimation[i].frames[j].y = 0;
mAnimation[i].frames[j].w = 0;
mAnimation[i].frames[j].h = 0;
}
}
mCurrentFrame = 0;
mAnimationCounter = 0;
}
// Calcula el frame correspondiente a la animación
void SpriteAnimated::animate(int index)
{
// Calculamos el frame actual a partir del contador
mCurrentFrame = mAnimationCounter / mAnimation[index].speed;
// Si alcanzamos el final de la animación, reiniciamos el contador de la animación
if (mCurrentFrame >= mAnimation[index].numFrames)
{
mAnimationCounter = 0;
}
// En caso contrario
else
{
// Escogemos el frame correspondiente de la animación
setSpriteClip(mAnimation[index].frames[mCurrentFrame]);
// Incrementamos el contador de la animacion
++mAnimationCounter;
}
}
// Establece el frame actual de la animación
void SpriteAnimated::setCurrentFrame(Uint8 num)
{
mCurrentFrame = num;
}
// Establece el numero de frames de la animacion
void SpriteAnimated::setAnimationCounter(Uint16 num)
{
mAnimationCounter = num;
}
// Establece el rectangulo para un frame de una animación
void SpriteAnimated::setAnimationFrames(Uint8 index_animation, Uint8 index_frame, int x, int y, int w, int h)
{
mAnimation[index_animation].frames[index_frame].x = x;
mAnimation[index_animation].frames[index_frame].y = y;
mAnimation[index_animation].frames[index_frame].w = w;
mAnimation[index_animation].frames[index_frame].h = h;
}
// Establece la velocidad de una animación
void SpriteAnimated::setAnimationSpeed(Uint8 index, Uint8 speed)
{
mAnimation[index].speed = speed;
}
// Establece el numero de frames de una animación
void SpriteAnimated::setAnimationNumFrames(Uint8 index, Uint8 num)
{
mAnimation[index].numFrames = num;
}
// Devuelve el rectangulo de una animación y frame concreto
SDL_Rect SpriteAnimated::getAnimationClip(Uint8 index_animation, Uint8 index_frame)
{
return mAnimation[index_animation].frames[index_frame];
#include "spriteanimated.h"
// Constructor
SpriteAnimated::SpriteAnimated()
{
init();
}
// Iniciador
void SpriteAnimated::init()
{
for (Uint8 i = 0; i < 20; i++)
{
mAnimation[i].numFrames = 0;
mAnimation[i].speed = 0;
for (Uint8 j = 0; i < 20; i++)
{
mAnimation[i].frames[j].x = 0;
mAnimation[i].frames[j].y = 0;
mAnimation[i].frames[j].w = 0;
mAnimation[i].frames[j].h = 0;
}
}
mCurrentFrame = 0;
mAnimationCounter = 0;
}
// Calcula el frame correspondiente a la animación
void SpriteAnimated::animate(int index)
{
// Calculamos el frame actual a partir del contador
mCurrentFrame = mAnimationCounter / mAnimation[index].speed;
// Si alcanzamos el final de la animación, reiniciamos el contador de la animación
if (mCurrentFrame >= mAnimation[index].numFrames)
{
mAnimationCounter = 0;
}
// En caso contrario
else
{
// Escogemos el frame correspondiente de la animación
setSpriteClip(mAnimation[index].frames[mCurrentFrame]);
// Incrementamos el contador de la animacion
++mAnimationCounter;
}
}
// Establece el frame actual de la animación
void SpriteAnimated::setCurrentFrame(Uint8 num)
{
mCurrentFrame = num;
}
// Establece el numero de frames de la animacion
void SpriteAnimated::setAnimationCounter(Uint16 num)
{
mAnimationCounter = num;
}
// Establece el rectangulo para un frame de una animación
void SpriteAnimated::setAnimationFrames(Uint8 index_animation, Uint8 index_frame, int x, int y, int w, int h)
{
mAnimation[index_animation].frames[index_frame].x = x;
mAnimation[index_animation].frames[index_frame].y = y;
mAnimation[index_animation].frames[index_frame].w = w;
mAnimation[index_animation].frames[index_frame].h = h;
}
// Establece la velocidad de una animación
void SpriteAnimated::setAnimationSpeed(Uint8 index, Uint8 speed)
{
mAnimation[index].speed = speed;
}
// Establece el numero de frames de una animación
void SpriteAnimated::setAnimationNumFrames(Uint8 index, Uint8 num)
{
mAnimation[index].numFrames = num;
}
// Devuelve el rectangulo de una animación y frame concreto
SDL_Rect SpriteAnimated::getAnimationClip(Uint8 index_animation, Uint8 index_frame)
{
return mAnimation[index_animation].frames[index_frame];
}

116
source/spriteanimated.h
View File

@@ -1,59 +1,59 @@
#pragma once
#include "sprite.h"
#include "const.h"
#include <iostream>
#ifndef SPRITEANIMATED_H
#define SPRITEANIMATED_H
// Clase spriteAnimated
class SpriteAnimated : public Sprite
{
public:
// Constructor
SpriteAnimated();
// Iniciador
void init();
// Calcula el frame correspondiente a la animación
void animate(int index);
// Establece el frame actual de la animación
void setCurrentFrame(Uint8 num);
// Establece el numero de frames de la animacion
void setAnimationCounter(Uint16 num);
// Establece el rectangulo para un frame de una animación
void setAnimationFrames(Uint8 index_animation, Uint8 index_frame, int x, int y, int w, int h);
// Establece la velocidad de una animación
void setAnimationSpeed(Uint8 index, Uint8 speed);
// Establece el numero de frames de una animación
void setAnimationNumFrames(Uint8 index, Uint8 num);
// Devuelve el rectangulo de una animación y frame concreto
SDL_Rect getAnimationClip(Uint8 index_animation, Uint8 index_frame);
private:
struct sAnimation
{
SDL_Rect frames[20];
Uint8 numFrames;
Uint8 speed;
};
// Vector con las diferentes animaciones y los diferentes frames de cada animación
sAnimation mAnimation[20];
// Frame actual
Uint8 mCurrentFrame;
// Contador para las animaciones
Uint16 mAnimationCounter;
};
#pragma once
#include "sprite.h"
#include "const.h"
#include <iostream>
#ifndef SPRITEANIMATED_H
#define SPRITEANIMATED_H
// Clase spriteAnimated
class SpriteAnimated : public Sprite
{
public:
// Constructor
SpriteAnimated();
// Iniciador
void init();
// Calcula el frame correspondiente a la animación
void animate(int index);
// Establece el frame actual de la animación
void setCurrentFrame(Uint8 num);
// Establece el numero de frames de la animacion
void setAnimationCounter(Uint16 num);
// Establece el rectangulo para un frame de una animación
void setAnimationFrames(Uint8 index_animation, Uint8 index_frame, int x, int y, int w, int h);
// Establece la velocidad de una animación
void setAnimationSpeed(Uint8 index, Uint8 speed);
// Establece el numero de frames de una animación
void setAnimationNumFrames(Uint8 index, Uint8 num);
// Devuelve el rectangulo de una animación y frame concreto
SDL_Rect getAnimationClip(Uint8 index_animation, Uint8 index_frame);
private:
struct sAnimation
{
SDL_Rect frames[20];
Uint8 numFrames;
Uint8 speed;
};
// Vector con las diferentes animaciones y los diferentes frames de cada animación
sAnimation mAnimation[20];
// Frame actual
Uint8 mCurrentFrame;
// Contador para las animaciones
Uint16 mAnimationCounter;
};
#endif

7897
source/stb_image.h Normal file
View File

File diff suppressed because it is too large Load Diff

5565
source/stb_vorbis.c Normal file
View File

File diff suppressed because it is too large Load Diff

98
source/text.cpp
View File

@@ -1,50 +1,50 @@
#include "text.h"
// Constructor
Text::Text()
{
init(NULL);
}
// Inicializador
void Text::init(LTexture *texture)
{
// Inicia los valores del sprite que dibuja las letras
mSprite.setWidth(8);
mSprite.setHeight(8);
mSprite.setPosX(0);
mSprite.setPosY(0);
mSprite.setTexture(*texture);
mSprite.setSpriteClip(8, 8, mSprite.getWidth(), mSprite.getHeight());
// Cadena con los caracteres ascii que se van a inicializar
std::string text = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-/().:#";
Uint8 i;
// Inicializa a cero el vector con las coordenadas
for (i = 0; i < 255; ++i)
{
mOffset[i].x = 0;
mOffset[i].y = 0;
}
// Establece las coordenadas para cada caracter ascii de la cadena
for (i = 0; i < text.length(); ++i)
{
mOffset[int(text[i])].x = (((int(text[i]) - 32) % 15) - 0) * BLOCK;
mOffset[int(text[i])].y = ((int(text[i]) - 32) / 15) * BLOCK;
}
}
// Escribe el texto en pantalla
void Text::write(int x, int y, std::string text)
{
;
for (Uint8 i = 0; i < text.length(); ++i)
{
mSprite.setSpriteClip(mOffset[int(text[i])].x, mOffset[int(text[i])].y, 8, 8);
mSprite.setPosX(x + (i * BLOCK));
mSprite.setPosY(y);
mSprite.render();
}
#include "text.h"
// Constructor
Text::Text()
{
init(NULL);
}
// Inicializador
void Text::init(LTexture *texture)
{
// Inicia los valores del sprite que dibuja las letras
mSprite.setWidth(8);
mSprite.setHeight(8);
mSprite.setPosX(0);
mSprite.setPosY(0);
mSprite.setTexture(*texture);
mSprite.setSpriteClip(8, 8, mSprite.getWidth(), mSprite.getHeight());
// Cadena con los caracteres ascii que se van a inicializar
std::string text = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-/().:#";
Uint8 i;
// Inicializa a cero el vector con las coordenadas
for (i = 0; i < 255; ++i)
{
mOffset[i].x = 0;
mOffset[i].y = 0;
}
// Establece las coordenadas para cada caracter ascii de la cadena
for (i = 0; i < text.length(); ++i)
{
mOffset[int(text[i])].x = (((int(text[i]) - 32) % 15) - 0) * BLOCK;
mOffset[int(text[i])].y = ((int(text[i]) - 32) / 15) * BLOCK;
}
}
// Escribe el texto en pantalla
void Text::write(int x, int y, std::string text)
{
;
for (Uint8 i = 0; i < text.length(); ++i)
{
mSprite.setSpriteClip(mOffset[int(text[i])].x, mOffset[int(text[i])].y, 8, 8);
mSprite.setPosX(x + (i * BLOCK));
mSprite.setPosY(y);
mSprite.render();
}
}

66
source/text.h
View File

@@ -1,34 +1,34 @@
#pragma once
#include "sprite.h"
#include "const.h"
#ifndef TEXT_H
#define TEXT_H
// Text class
class Text
{
public:
// Constructor
Text();
// Inicializador
void init(LTexture *texture);
// Escribe el texto en pantalla
void write(int x, int y, std::string text);
private:
// Objeto con los graficos para el texto
Sprite mSprite;
// Coordenadas dentro del PNG para cada código ascii
struct Offset
{
int x;
int y;
} mOffset[255];
};
#pragma once
#include "sprite.h"
#include "const.h"
#ifndef TEXT_H
#define TEXT_H
// Text class
class Text
{
public:
// Constructor
Text();
// Inicializador
void init(LTexture *texture);
// Escribe el texto en pantalla
void write(int x, int y, std::string text);
private:
// Objeto con los graficos para el texto
Sprite mSprite;
// Coordenadas dentro del PNG para cada código ascii
struct Offset
{
int x;
int y;
} mOffset[255];
};
#endif

BIN
super_pang_clone_linux
View File

Binary file not shown.