Ir al contenido

publicidad
publicidad

Foto

Curso MM: 22 Un ejemplo de uso del motor


Este tema ha sido archivado. Esto significa que no puedes responder en este tema.
No hay respuestas en este tema

#1

Escrito 29 agosto 2009 - 23:11

Este ejemplo fue lo primero que hice después de leer el libro por primera vez. Está hecho sobre la marcha, sin planificar, sin utilizar las estructuras de datos adecuadas, sin aprovechar tampoco el motor (no se utiliza la detección de colisiones ni los sprites), etc... Por lo tanto no es un buen ejemplo de uso del motor pero si sirve para ver cosas que se pueden hacer con él.

Voya a ir buscando y comentando los cambios que se han hecho. Para compilar el ejemplo hay que añadir al proyecto los siguientes archivos: adejw.cpp, adejw.rc, background.cpp, bitmap.cpp, gameengine.cpp, Resource.h y Sprite.cpp
Además hay que añadir al proyecto la librería libwinmm.a (suponiendo que se use Dev-c++.

En Resource.h están los códigos para iconos, imágenes y sonidos.
En adejw.rc está la ubicación de todos los archivos de iconos, imágenes y sonidos.

En el archivo GameEngine.h aparece la declaración de una nueva función para el motor. Se trata de un sistema para capturar el texto introducido por el jugador:
[code:1]void HandleKeysForText(int x, BOOL bup0down1);[/code]

En GameEngine.cpp tenemos que irnos hasta GameEngine::HandleEvent(); para ver que en el bucle principal de mensajes se han añadido dos nuevos "case":

[code:1]case WM_KEYDOWN:
// se encarga del teclado para escribir texto.
if(wParam == VK_SHIFT)
{
HandleKeysForText(wParam,TRUE);
return 0;
}
if(wParam != VK_DOWN && wParam != VK_UP && wParam != VK_LEFT && wParam != VK_RIGHT)
{
HandleKeysForText(wParam,FALSE);
}
return 0;

case WM_KEYUP:
if(wParam == VK_SHIFT) HandleKeysForText(wParam,FALSE);
return 0;[/code]

Ahora vamos a ver adejw.h:
[code:1]//-----------------------------------------------------------------
// Adejw Application
// C++ Header
//-----------------------------------------------------------------

#pragma once

//-----------------------------------------------------------------
// Include Files
//-----------------------------------------------------------------
#include
#include "Resource.h"
#include "GameEngine.h"
#include "Bitmap.h"
#include "Sprite.h"
#include "Background.h"
#include "math.h"

//-----------------------------------------------------------------
// Global Variables
//-----------------------------------------------------------------
HINSTANCE _hInstance;
GameEngine* _pGame;
HDC _hOffscreenDC;
HBITMAP _hOffscreenBitmap;
Bitmap* _pSplashBitmap;
Bitmap* _pMainCharBitmap;
Bitmap* _pMacheteBitmap;
Bitmap* _pPalaBitmap;
Bitmap* _pPicoBitmap;
Bitmap* _pBolsaBitmap;
Bitmap* _pBallestaBitmap;
Bitmap* _pAguaBitmap;
Bitmap* _pArbolBitmap;
Bitmap* _pMontanaBitmap;
Bitmap* _pHierbaBitmap;
Bitmap* _pGameOverBitmap;
Bitmap* _pFondoBitmap;
Bitmap* _pDemonskeletonBitmap;
Bitmap* _pBugBitmap;
Bitmap* _pVenenoBitmap;
Bitmap* _pSelectionBitmap;
StarryBackground* _pBackground; //copié el esqueleto del programa del
//último ejemplo del libro y hay variables
//que no se usan en éste.
Sprite* _pSprite;
int _iFireInputDelay; //retraso para disparar.
int _iNumLives, _iScore, _iDifficulty;
BOOL _bGameOver;
int _iGameOverDelay;
BOOL _bDemo;

Bitmap* _pMapa[100][100]; //tabla para el mapa de 100x100 bitmaps.
int _iMoveDelay,_iMoveDelay2,_iMoveDelay3,_iMoveDelay4; //retrasos de movimiento.
BOOL _bShowText = FALSE; //indica si se muestra el texto introducido por el usuario sobre
//el personaje.
int _iShowTextDelay; //retraso para el texto.
TCHAR _szLineText[64]; // para guardar la línea de texto escrito.
int _iLineTextCounter = 0; //contador de letras en el buffer.
TCHAR szText[64]; // Para el texto sobre el personaje.
BOOL _bShiftActive = 0; //indica si se pulsó la tecla para mayúsculas.
BOOL _bDragging = FALSE; //indica si estamos arrastrando algo con el ratón.
int _iObjectDragged; //número del objeto que está siendo arrastrado.
int _iInitialxObjectDragged,_iInitialyObjectDragged; //posición inicial del objeto arrastrado, por si hay que recuperarla.
int _iMouseClickx,_iMouseClicky; //guarda las x,y del ratón.
int _iMoveMonsters = 0; //para saber hacia dónde muevo al monstruo.
int _iNumberOfBullets;
int _iMonsterSelected; //número del monstruo seleccionado actualmente.
BOOL _bDraggedFromInvent = FALSE; //indica si ha sido arrastrado desde el inventario.
int _iHuecoInvent; //hueco del inventario desde el que se arrastra algo.

struct Mapa
{
TCHAR name[15];
Bitmap* _pBitmap;
};

Mapa Mapa[100][100];

struct Inventario
{
unsigned char id; //identificación del hueco del inventario.
#define INV_CASCO 0 //395,111
#define INV_CUELLO 1 //360,122
#define INV_MOCHILA 2 //431,122
#define INV_PECHO 3 //395,148
#define INV_MANOD 4 //360,159
#define INV_MANOI 5 //431,160
#define INV_ANILLO 6 //360,196
#define INV_PIERNAS 7 //395,186
#define INV_MUNICION 8 //431,198
#define INV_PIES 9 //395,222
#define INV_NUMHUECOS 10
int x,y; //coordenadas x,y en la pantalla.
int objeto; //número del objeto en caso de haber alguno.
};

struct MainChar
{
int x,y; //posición en el mapa.
int xdest,ydest; //posición de destino si se ha pulsado con el ratón.
TCHAR name[15];
int hp,hpmax; //vida actual y máxima.
int mana,manamax; //magia actual y máxima.
Bitmap* _pBitmap;
Inventario _Inventario[10]; //creo el inventario, hay que inicializarlo.
};

MainChar MainChar; //creo el personaje principal.

struct Objects
{
int x,y; //posición en el mapa.
unsigned char tipo; //tipo de objeto.
#define OBJ_CASCO 0
#define OBJ_CUELLO 1
#define OBJ_MOCHILA 2
#define OBJ_CORAZA 3
#define OBJ_ARMA 4
#define OBJ_HERRAM 5
#define OBJ_ANILLO 6
#define OBJ_PIERNAS 7
#define OBJ_MUNICION 8
#define OBJ_PIES 9
#define OBJ_NUMTIPOS 10
TCHAR name[15];
Bitmap* _pBitmap; //el gráfico que lo representa.
unsigned char where; /* Dónde cree el objeto que está */
#define OBJ_FREE 0 /* en ningún sitio */
#define OBJ_FLOOR 1 /* en el suelo */
#define OBJ_CONTAINED 2 /* en un contenedor */
#define OBJ_INVENT 3 /* en el inventario del personaje */
#define OBJ_MINVENT 4 /* en el inventario de un monstruo */
#define OBJ_MIGRATING 5 /* enviado a otro nivel */
#define OBJ_BURIED 6 /* enterrado */
#define OBJ_ONBILL 7 /* en la cuenta para pagar */
#define NOBJ_STATES 8 /* número de estados de lugar de los objetos */
};

#define MAXNUM_OBJECTS 5
Objects Objects[MAXNUM_OBJECTS]; //creo espacio para 5 objetos.

struct Monsters
{
int x,y; //posición en el mapa.
TCHAR name[15];
int hit; //cantidad de energía que quitan.
Bitmap* _pBitmap; //el gráfico que lo representa.
};

#define MAXNUM_MONSTERS 2
Monsters Monsters[MAXNUM_MONSTERS]; //creo espacio para 2 monstruos.

struct Bullets
{
int x,y; //posición en la pantalla (no en el mapa).
int xdest,ydest; //posición de destino.
Bitmap* _pBitmap;
};

#define MAXNUM_BULLETS 5
Bullets Bullets[5];

//-----------------------------------------------------------------
// Function Declarations
//-----------------------------------------------------------------
void NewGame();
BOOL is_open(int x,int y); //devuelve si se puede andar por esa casilla o no.
BOOL is_near(int x,int y); //devuelve si unas coordenadas están cerca del personaje principal o no.
void UpdateBullets(); //actualiza los proyectiles.[/code]



Y ahora vamos con adejw.cpp
[code:1]
//-----------------------------------------------------------------
// Include Files
//-----------------------------------------------------------------
#include "adejw.h"

//-----------------------------------------------------------------
// Game Engine Functions
//-----------------------------------------------------------------
BOOL GameInitialize(HINSTANCE hInstance)
{
...
//nada de interés aquí.
...
}

void GameStart(HWND hWindow)
{
...
//Inicializaciones varias y carga de bitmaps
...

//Inicializo el mapa con un borde de agua.
for(int a=0;a<100;a++)
{
Mapa[a][0]._pBitmap=_pAguaBitmap; //0 es agua.
wsprintf(Mapa[a][0].name,"Agua");
Mapa[a][1]._pBitmap=_pAguaBitmap;
wsprintf(Mapa[a][1].name,"Agua");
Mapa[a][2]._pBitmap=_pAguaBitmap;
wsprintf(Mapa[a][2].name,"Agua");
Mapa[a][3]._pBitmap=_pAguaBitmap;
wsprintf(Mapa[a][3].name,"Agua");
Mapa[a][4]._pBitmap=_pAguaBitmap;
wsprintf(Mapa[a][4].name,"Agua");
Mapa[a][99]._pBitmap=_pAguaBitmap;
wsprintf(Mapa[a][99].name,"Agua");
Mapa[a][98]._pBitmap=_pAguaBitmap;
wsprintf(Mapa[a][98].name,"Agua");
Mapa[a][97]._pBitmap=_pAguaBitmap;
wsprintf(Mapa[a][97].name,"Agua");
Mapa[a][96]._pBitmap=_pAguaBitmap;
wsprintf(Mapa[a][96].name,"Agua");
Mapa[a][95]._pBitmap=_pAguaBitmap;
wsprintf(Mapa[a][95].name,"Agua");

Mapa[0][a]._pBitmap=_pAguaBitmap; //0 es agua.
wsprintf(Mapa[0][a].name,"Agua");
Mapa[1][a]._pBitmap=_pAguaBitmap;
wsprintf(Mapa[1][a].name,"Agua");
Mapa[2][a]._pBitmap=_pAguaBitmap;
wsprintf(Mapa[2][a].name,"Agua");
Mapa[3][a]._pBitmap=_pAguaBitmap;
wsprintf(Mapa[3][a].name,"Agua");
Mapa[4][a]._pBitmap=_pAguaBitmap;
wsprintf(Mapa[4][a].name,"Agua");
Mapa[99][a]._pBitmap=_pAguaBitmap;
wsprintf(Mapa[99][a].name,"Agua");
Mapa[98][a]._pBitmap=_pAguaBitmap;
wsprintf(Mapa[98][a].name,"Agua");
Mapa[97][a]._pBitmap=_pAguaBitmap;
wsprintf(Mapa[97][a].name,"Agua");
Mapa[96][a]._pBitmap=_pAguaBitmap;
wsprintf(Mapa[96][a].name,"Agua");
Mapa[95][a]._pBitmap=_pAguaBitmap;
wsprintf(Mapa[95][a].name,"Agua");
}
//Ahora relleno el interior del mapa de forma aleatoria con cosas.
int aux1;
for(int x=5;x<95;x++)
{
for(int y=5;y<95;y++)
{
aux1 = rand() % 100;
if(aux1 > 90)
{
Mapa[x][y]._pBitmap=_pMontanaBitmap;
wsprintf(Mapa[x][y].name,"Montaña");
}
else
{
if(aux1 > 60)
{
Mapa[x][y]._pBitmap=_pArbolBitmap;
wsprintf(Mapa[x][y].name,"Árbol");
}
else
{
Mapa[x][y]._pBitmap=_pHierbaBitmap;
wsprintf(Mapa[x][y].name,"Hierba");
}
}
}
}

//inicializo la posición del personaje en el mapa.
MainChar.x = MainChar.y = MainChar.xdest = MainChar.ydest = 6;
MainChar._pBitmap = _pMainCharBitmap;
wsprintf(MainChar.name,"El Justiciero");
MainChar.hpmax = 200;
MainChar.hp = 200;
MainChar.manamax = 200;
MainChar.mana = 200;

//inicializo el inventario.
MainChar._Inventario[0].id = INV_CASCO;
MainChar._Inventario[0].x = 395;
MainChar._Inventario[0].y = 111;
MainChar._Inventario[1].id = INV_CUELLO;
MainChar._Inventario[1].x = 360;
MainChar._Inventario[1].y = 122;
MainChar._Inventario[2].id = INV_MOCHILA;
MainChar._Inventario[2].x = 431;
MainChar._Inventario[2].y = 122;
MainChar._Inventario[3].id = INV_PECHO;
MainChar._Inventario[3].x = 395;
MainChar._Inventario[3].y = 148;
MainChar._Inventario[4].id = INV_MANOD;
MainChar._Inventario[4].x = 360;
MainChar._Inventario[4].y = 159;
MainChar._Inventario[5].id = INV_MANOI;
MainChar._Inventario[5].x = 431;
MainChar._Inventario[5].y = 160;
MainChar._Inventario[6].id = INV_ANILLO;
MainChar._Inventario[6].x = 360;
MainChar._Inventario[6].y = 196;
MainChar._Inventario[7].id = INV_PIERNAS;
MainChar._Inventario[7].x = 395;
MainChar._Inventario[7].y = 186;
MainChar._Inventario[8].id = INV_MUNICION;
MainChar._Inventario[8].x = 431;
MainChar._Inventario[8].y = 198;
MainChar._Inventario[9].id = INV_PIES;
MainChar._Inventario[9].x = 395;
MainChar._Inventario[9].y = 222;
for(int a=0;a<10;a++)
{
MainChar._Inventario[a].objeto = MAXNUM_OBJECTS; //uno más de los objetos existentes.
}

//creo los objetos, les doy posición y gráfico.
int aux2 = 10;
for(int a=0;a {
Objects[a].x = Objects[a].y = aux2--;
Objects[a].where = OBJ_FLOOR; //todos los objetos están en el suelo.
}
Objects[0]._pBitmap =_pMacheteBitmap;
wsprintf(Objects[0].name,"Machete");
Objects[0].tipo = OBJ_ARMA;
Objects[1]._pBitmap =_pPalaBitmap;
wsprintf(Objects[1].name,"Pala");
Objects[1].tipo = OBJ_HERRAM;
Objects[2]._pBitmap =_pPicoBitmap;
wsprintf(Objects[2].name,"Pico");
Objects[2].tipo = OBJ_HERRAM;
Objects[3]._pBitmap =_pBolsaBitmap;
wsprintf(Objects[3].name,"Bolsa");
Objects[3].tipo = OBJ_MOCHILA;
Objects[4]._pBitmap =_pBallestaBitmap;
wsprintf(Objects[4].name,"Ballesta");
Objects[5].tipo = OBJ_ARMA;

//Creo los monstruos, dándoles posición y gráfico.
Monsters[0].x = 10;
Monsters[0].y = 6;
Monsters[0].hit = 10;
Monsters[0]._pBitmap = _pDemonskeletonBitmap;
wsprintf(Monsters[0].name,"Demon Skeleton");
Monsters[1].x = 6;
Monsters[1].y = 10;
Monsters[1].hit = 2;
Monsters[1]._pBitmap = _pBugBitmap;
wsprintf(Monsters[1].name,"Bug");
_iMonsterSelected = MAXNUM_MONSTERS; //le doy un valor mayor que el número de monstruos que existen.

//inicializo los proyectiles.
_iNumberOfBullets = 0;

_bDemo = TRUE;
NewGame();
}

void GameEnd()
{
...
// cerrar la música, eliminar los bitmaps y el motor.
...

}

void GameActivate(HWND hWindow)
{
if (!_bDemo)
// Resume the background music
_pGame->PlayMIDISong(TEXT(""), FALSE);
}

void GameDeactivate(HWND hWindow)
{
if (!_bDemo)
// Pause the background music
_pGame->PauseMIDISong();
}

void GamePaint(HDC hDC)
{

//Dibujo el fondo.
_pFondoBitmap->Draw(hDC,0,0,TRUE);

// Dibujar el fondo de la zona de juego.
int xoffset=0;
int yoffset=0;
for(int x=MainChar.x-5;x {
for(int y=MainChar.y-5;y {
//Dibujo el suelo (hierba/árbol/monaña).
Mapa[x][y]._pBitmap->Draw(hDC,xoffset,yoffset,FALSE);
//si hay un objeto allí lo dibujo también.
for(int a=0;a {
if(x==Objects[a].x && y==Objects[a].y && Objects[a].where==OBJ_FLOOR) Objects[a]._pBitmap->Draw(hDC,xoffset,yoffset,TRUE);
}
//si hay un monstruo lo dibujo.
for(int a=0;a {
if(x==Monsters[a].x && y==Monsters[a].y)
{
Monsters[a]._pBitmap->Draw(hDC,xoffset,yoffset,TRUE);
if(_iMonsterSelected==a) _pSelectionBitmap->Draw(hDC,xoffset,yoffset,TRUE);
}
}
yoffset = yoffset + 32;
}
yoffset = 0;
xoffset = xoffset + 32;
}

// Dibujo las balas.
for(int a=0;a<_iNumberOfBullets;a++)
{
Bullets[a]._pBitmap->Draw(hDC,Bullets[a].x-(MainChar.x-5)*32,Bullets[a].y-(MainChar.y-5)*32,TRUE);
}

//Dibujo los objetos del inventario si los hay.
for(int a=0;a<10;a++)
{
if(MainChar._Inventario[a].objeto != MAXNUM_OBJECTS) Objects[MainChar._Inventario[a].objeto]._pBitmap->Draw(hDC,MainChar._Inventario[a].x,MainChar._Inventario[a].y,TRUE);
}

// Draw the sprites
_pGame->DrawSprites(hDC);

//Dibujar el personaje principal.
MainChar._pBitmap->Draw(hDC,160,160,TRUE);

//Dibujar la barra de energía y de magia del personaje principal.
HBRUSH hRedBrush = CreateSolidBrush(RGB(255,0, 0));
HBRUSH hBlackBrush = CreateSolidBrush(RGB(0,0,0));
HBRUSH hBlueBrush = CreateSolidBrush(RGB(0, 0, 255));
SelectObject(hDC, hBlackBrush);
Rectangle(hDC,352,0,452,10);
SelectObject(hDC, hRedBrush);
Rectangle(hDC,352,0,352+MainChar.hp*100/MainChar.hpmax,10);

SelectObject(hDC, hBlackBrush);
Rectangle(hDC,352,10,452,20);
SelectObject(hDC, hBlueBrush);
Rectangle(hDC,352,10,352+MainChar.mana*100/MainChar.manamax,20);
DeleteObject(hRedBrush);
DeleteObject(hBlackBrush);
DeleteObject(hBlueBrush);

if (_bDemo)
{
// Draw the splash screen image
_pSplashBitmap->Draw(hDC, 0, 0, FALSE);
}
else
{
// Draw the game over message, if necessary
if (_bGameOver)
_pGameOverBitmap->Draw(hDC, 170, 100, TRUE);
}

// Escribo el texto sobre el personaje si es necesario (si lo hay y no ha pasado el retraso para borrarlo).
if(_bShowText && (--_iShowTextDelay > 0))
{
RECT rect = {100,100,220,160};
SetBkMode(hDC, TRANSPARENT);
SetTextColor(hDC, RGB(239, 179, 0));
DrawText(hDC, szText, -1, &rect, DT_WORDBREAK | DT_CENTER | DT_VCENTER);
}

// Escribir el texto en la parte en la que se escribe (abajo).
RECT rect2 = {30,405,595,425};
SetBkMode(hDC, TRANSPARENT);
SetTextColor(hDC, RGB(239,179,0));
DrawText(hDC,_szLineText,-1, &rect2, DT_SINGLELINE | DT_LEFT);
}

void GameCycle()
{
if (!_bGameOver)
{
// Update the sprites
_pGame->UpdateSprites();
UpdateBullets();

//Actualizo la posición de los monstruos.
if(++_iMoveDelay3 > 20)
{
for(int a=0;a {
//compruebo si el monstruo está justo al lado del personaje principal.
if(is_near(Monsters[a].x,Monsters[a].y))
{
//si lo está resto un golpe del monstruo a la salud del prota.
if(MainChar.hp > 0) MainChar.hp = MainChar.hp - Monsters[a].hit;
}
//compruebo si el personaje principal está cerca del monstruo.
if(abs(Monsters[a].x-MainChar.x)<6 && abs(Monsters[a].y-MainChar.y)<6)
{
if(Monsters[a].x {
if(is_open(Monsters[a].x+1,Monsters[a].y)) Monsters[a].x++;
}
else
{
if(is_open(Monsters[a].x-1,Monsters[a].y)) Monsters[a].x--;
}
if(Monsters[a].y {
if(is_open(Monsters[a].x,Monsters[a].y+1)) Monsters[a].y++;
}
else
{
if(is_open(Monsters[a].x,Monsters[a].y-1)) Monsters[a].y--;
}
}
else
{
switch(_iMoveMonsters)
{
case 0:
if(is_open(Monsters[a].x+1,Monsters[a].y)) Monsters[a].x++;
break;
case 1:
if(is_open(Monsters[a].x-1,Monsters[a].y)) Monsters[a].x--;
break;
case 2:
if(is_open(Monsters[a].x,Monsters[a].y+1)) Monsters[a].y++;
break;
case 3:
if(is_open(Monsters[a].x,Monsters[a].y-1)) Monsters[a].y--;
break;
default:
break;
}
}
}
_iMoveMonsters++;
if(_iMoveMonsters == 4) _iMoveMonsters=0;
_iMoveDelay3 = 0;
}

//Actualizo la posición del personaje haciéndole ir hacia donde se pulsó el
//botón del ratón.
if(++_iMoveDelay2 > 4)
{
if(MainChar.x {
if(is_open(MainChar.x+1,MainChar.y)) MainChar.x++;
}
else
{
if(MainChar.x>MainChar.xdest) if(is_open(MainChar.x-1,MainChar.y)) MainChar.x--;
}
if(MainChar.y {
if(is_open(MainChar.x,MainChar.y+1)) MainChar.y++;
}
else
{
if(MainChar.y>MainChar.ydest) if(is_open(MainChar.x,MainChar.y-1)) MainChar.y--;
}
_iMoveDelay2 = 0;
}

// Obtain a device context for repainting the game
HWND hWindow = _pGame->GetWindow();
HDC hDC = GetDC(hWindow);

// Paint the game to the offscreen device context
GamePaint(_hOffscreenDC);

// Blit the offscreen bitmap to the game screen
BitBlt(hDC, 0, 0, _pGame->GetWidth(), _pGame->GetHeight(),
_hOffscreenDC, 0, 0, SRCCOPY);

// Cleanup
ReleaseDC(hWindow, hDC);
}
else
if (--_iGameOverDelay == 0)
{
// Stop the music and switch to demo mode
_pGame->PauseMIDISong();
_bDemo = TRUE;
NewGame();
}
}

void HandleKeys() // para mover al personaje.
{
if (!_bGameOver && !_bDemo)
{
// Move the char based upon left/right key presses
if ((++_iMoveDelay > 12) && GetAsyncKeyState(VK_LEFT) < 0)
{
// Move left
if(is_open(MainChar.x-1,MainChar.y)) MainChar.x--;

MainChar.xdest = MainChar.x;
MainChar.ydest = MainChar.y;
_iMoveDelay=0;
}
else if ((++_iMoveDelay > 12) && GetAsyncKeyState(VK_RIGHT) < 0)
{
// Move right
if(is_open(MainChar.x+1,MainChar.y)) MainChar.x++;

MainChar.xdest = MainChar.x;
MainChar.ydest = MainChar.y;
_iMoveDelay=0;
}
else if ((++_iMoveDelay > 12) && GetAsyncKeyState(VK_UP) < 0)
{
//Move up
if(is_open(MainChar.x,MainChar.y-1)) MainChar.y--;

MainChar.xdest = MainChar.x;
MainChar.ydest = MainChar.y;
_iMoveDelay=0;
}
else if ((++_iMoveDelay > 12) && GetAsyncKeyState(VK_DOWN) < 0)
{
//Move down
if(is_open(MainChar.x,MainChar.y+1)) MainChar.y++;

MainChar.xdest = MainChar.x;
MainChar.ydest = MainChar.y;
_iMoveDelay=0;
}

}

// creo un sprite de disparo al pulsar la tecla END.
if(_iMoveDelay4++>4 && GetAsyncKeyState(VK_END) < 0)
{
// Play the missile (fire) sound
PlaySound((LPCSTR)IDW_MISSILE, _hInstance, SND_ASYNC |
SND_RESOURCE | SND_NOSTOP);

Bullets[_iNumberOfBullets].x = MainChar.x*32;
Bullets[_iNumberOfBullets].y = MainChar.y*32;
Bullets[_iNumberOfBullets].xdest = (MainChar.x+5)*32;
Bullets[_iNumberOfBullets].ydest = (MainChar.y+5)*32;
Bullets[_iNumberOfBullets]._pBitmap = _pVenenoBitmap;
if(_iNumberOfBullets < MAXNUM_BULLETS) _iNumberOfBullets++;

Bullets[_iNumberOfBullets].x = (MainChar.x+5)*32;
Bullets[_iNumberOfBullets].y = MainChar.y*32;
Bullets[_iNumberOfBullets].xdest = (MainChar.x)*32;
Bullets[_iNumberOfBullets].ydest = (MainChar.y)*32;
Bullets[_iNumberOfBullets]._pBitmap = _pVenenoBitmap;
if(_iNumberOfBullets < MAXNUM_BULLETS) _iNumberOfBullets++;
_iMoveDelay4 = 0;
}

// Start a new game based upon an Enter (Return) key press
if (GetAsyncKeyState(VK_RETURN) < 0)
{
if (_bDemo)
{
// Switch out of demo mode to start a new game
_bDemo = FALSE;
NewGame();
}
else if (_bGameOver)
{
// Start a new game
NewGame();
}
}
}

void HandleKeysForText(int key, BOOL bup0down1) //necesita cambios en gameengine.h y .cpp
{
TCHAR texto[64];

if(key==VK_END) return;
if(key==VK_CONTROL) return;
if(key==VK_SHIFT) return;
if(key==VK_MENU) return;
if(bup0down1==FALSE && key==VK_SHIFT) _bShiftActive = FALSE;
if(bup0down1==TRUE && key==VK_SHIFT) _bShiftActive = TRUE;
if(key!=VK_SHIFT)
{
if(key>=65 && key<=90 && _bShiftActive == FALSE) key = key +32; //convierto mayúsculas a minúsculas.

if(key!=VK_RETURN)
{
if(_iLineTextCounter {
wsprintf(texto,"%c",key);
strcat(_szLineText,texto);
_iLineTextCounter++;
}
}
else
{
_bShowText = TRUE;
_iShowTextDelay = 50;
memset(szText,0,64);
strcat(szText,_szLineText);
memset(_szLineText,0,64);
_iLineTextCounter=0;
}
}
}

void MouseButtonDown(int x, int y, BOOL bLeft) //sobre todo para controlar el arrastre de objetos.
{
_iMouseClickx = x/32+MainChar.x-5;
_iMouseClicky = y/32+MainChar.y-5;
if (bLeft && !_bDragging && x<352 && y<352 && is_near((x/32+(MainChar.x-5)),(y/32+(MainChar.y-5)))==TRUE)
{
//mirar si hay algún objeto debajo.
for(int a=0;a {
if((x/32+(MainChar.x-5))==Objects[a].x && (y/32+(MainChar.y-5))==Objects[a].y && Objects[a].where==OBJ_FLOOR)
{
_iObjectDragged = a;
_iInitialxObjectDragged = Objects[a].x;
_iInitialyObjectDragged = Objects[a].y;
a = 6; //salgo del for.

// Capture the mouse
SetCapture(_pGame->GetWindow());

// Set the drag state and the drag ball
_bDragging = TRUE;
_bDraggedFromInvent = FALSE; //no arrastrado desde el inventario.
_iHuecoInvent = 20; //ningún hueco.

// Simulate a mouse move to get started
MouseMove(x, y);
}
}
}
else //compruebo si se arrastra algo desde el inventario.
{
for(int a=0;a<10;a++)
{
if(bLeft && !_bDragging && x>MainChar._Inventario[a].x && xMainChar._Inventario[a].y && y {
_iObjectDragged = MainChar._Inventario[a].objeto;
_bDraggedFromInvent = TRUE;
_iHuecoInvent = a;
_iInitialxObjectDragged = MainChar.x;
_iInitialyObjectDragged = MainChar.y;
a = 10; //salgo del for.

// Capture the mouse
SetCapture(_pGame->GetWindow());

// Set the drag state and the drag ball
_bDragging = TRUE;

// Simulate a mouse move to get started
MouseMove(x, y);
}
}
}
}

void MouseButtonUp(int x, int y, BOOL bLeft) //sobre todo para controlar dónde se sueltan objetos tras arrastrarlos.
{
// Release the mouse
ReleaseCapture();
BOOL aux = FALSE; //indica si el objeto ha sido movido del inventario a
// otro sitio que no es el mapa ni el inventario.

if(_bDragging==TRUE)
{
if(x<352 && y<352) //ésto lo hago si está dentro de la pantalla.
{
if(_bDraggedFromInvent==TRUE) //si fué arrastrado desde el inventario.
{
_bDraggedFromInvent=FALSE;
MainChar._Inventario[_iHuecoInvent].objeto=MAXNUM_OBJECTS; //elimino el objeto.
//Objects[_iObjectDragged].where=OBJ_FLOOR;
}
//por defecto lo pongo en el suelo.
Objects[_iObjectDragged].where=OBJ_FLOOR;
//si cae al agua lo marco como objeto en ningún sitio.
if(Mapa[(x/32)+MainChar.x-5][(y/32)+MainChar.y-5]._pBitmap==_pAguaBitmap) Objects[_iObjectDragged].where=OBJ_FREE;
}
else //compruebo si ha sido arrastrado al inventario.
{
Objects[_iObjectDragged].where=OBJ_FLOOR;
Objects[_iObjectDragged].x=_iInitialxObjectDragged;
Objects[_iObjectDragged].y=_iInitialyObjectDragged;
for(int a=0;a<10;a++)
{
if(x>MainChar._Inventario[a].x && xMainChar._Inventario[a].y && y {
aux = TRUE;
if(MainChar._Inventario[a].objeto==MAXNUM_OBJECTS) //compruebo que esté vacío.
{
Objects[_iObjectDragged].where=OBJ_INVENT;
MainChar._Inventario[a].objeto = _iObjectDragged;
if(_bDraggedFromInvent==TRUE)
{
_bDraggedFromInvent=FALSE;
MainChar._Inventario[_iHuecoInvent].objeto=MAXNUM_OBJECTS;
}
}
else //si ya está ocupado hay que dejarlo todo como estaba.
{
if(_bDraggedFromInvent==TRUE)
{
MainChar._Inventario[_iHuecoInvent].objeto=_iObjectDragged;
Objects[_iObjectDragged].where=OBJ_INVENT;
}
}
}
}
if(aux==FALSE && _bDraggedFromInvent==TRUE) //el objeto ha sido arrastrado desde el inventario hacia
{ //un lugar que no es el mapa ni el inventario.
//dejarlo como estaba.
MainChar._Inventario[_iHuecoInvent].objeto=_iObjectDragged;
Objects[_iObjectDragged].where=OBJ_INVENT;
}
}
}
// Stop dragging
_bDragging = FALSE;
//compruebo si se ha pulsado en el inventario.
for(int a=0;a<10;a++)
{
if(x>MainChar._Inventario[a].x && xMainChar._Inventario[a].y && y {
_bShowText = TRUE;
_iShowTextDelay = 50;
wsprintf(szText,"%s",Objects[MainChar._Inventario[a].objeto].name);
return;
}
}

if(_iMouseClickx==x/32+MainChar.x-5 && _iMouseClicky==y/32+MainChar.y-5 && x<32*11 && y<32*11)
{
if(GetAsyncKeyState(VK_MENU) < 0)
{
//se ha pulsado la tecla ALT. (atacar).
_bShowText = TRUE;
_iShowTextDelay = 50;
memset(szText,0,64);
//strcat(szText,"pulsada la tecla ALT");
//mirar si hay un monstruo debajo.
for(int a=0;a {
if((x/32+MainChar.x-5)==Monsters[a].x && (y/32+MainChar.y-5)==Monsters[a].y)
{
if(_iMonsterSelected == a)
{ _iMonsterSelected = MAXNUM_MONSTERS; }//quitar la selección.
else { _iMonsterSelected = a;} //poner la selección.
}
}
return;
}
if(GetAsyncKeyState(VK_SHIFT) < 0)
{
//se ha pulsado la tecla SHIFT. (mirar).
_bShowText = TRUE;
_iShowTextDelay = 50;
memset(szText,0,64);
//strcat(szText,"pulsada la tecla SHIFT");
//compruebo si es el personaje principal.
if(x/32+MainChar.x-5==MainChar.x && y/32+MainChar.y-5==MainChar.y)
{
wsprintf(szText,"Ves a %s",MainChar.name);
return;
}
else
{
//compruebo si es un monstruo.
for(int a=0;a {
if(x/32+MainChar.x-5==Monsters[a].x && y/32+MainChar.y-5==Monsters[a].y)
{
wsprintf(szText,"%s",Monsters[a].name);
return;
}
}
//compruebo si es un objeto.
for(int a=0;a {
if((x/32+MainChar.x-5)==Objects[a].x && (y/32+MainChar.y-5)==Objects[a].y && Objects[a].where==OBJ_FLOOR)
{
wsprintf(szText,"%s",Objects[a].name);
return;
}
}
//compruebo si es agua,hierba,árbol o montaña.
wsprintf(szText,"%s",Mapa[x/32+MainChar.x-5][y/32+MainChar.y-5].name);
}
return;
}
if(GetAsyncKeyState(VK_CONTROL) < 0)
{
//se ha pulsado la tecla CONTROL. (usar).
_bShowText = TRUE;
_iShowTextDelay = 50;
memset(szText,0,64);
strcat(szText,"pulsada la tecla CONTROL");
return;
}
MainChar.xdest = (x/32+MainChar.x-5);
MainChar.ydest = (y/32+MainChar.y-5);
}
}

void MouseMove(int x, int y) //controla si algo se arrastra.
{
if (_bDragging)
{
if(x>32*11 || y>32*11)
{
Objects[_iObjectDragged].x=_iInitialxObjectDragged;
Objects[_iObjectDragged].y=_iInitialyObjectDragged;
}
else
{
Objects[_iObjectDragged].x=(x/32)+MainChar.x-5;
Objects[_iObjectDragged].y=(y/32)+MainChar.y-5;
}
}
}

void HandleJoystick(JOYSTATE jsJoystickState)
{
}

BOOL SpriteCollision(Sprite* pSpriteHitter, Sprite* pSpriteHittee)
{
return FALSE;
}

void SpriteDying(Sprite* pSprite)
{
}

//-----------------------------------------------------------------
// Functions
//-----------------------------------------------------------------
void NewGame()
{
// Clear the sprites
_pGame->CleanupSprites();

// Initialize the game variables
_iFireInputDelay = 0;
_iScore = 0;
_iNumLives = 3;
_iDifficulty = 80;
_bGameOver = FALSE;

if (_bDemo)
{
// Add a few sprite-elements to the demo.
}
else
{
// Create the main char sprite
//RECT rcBounds = { 0, 0, 600, 450 };
//_pMainCharSprite = new Sprite(_pMainCharBitmap, rcBounds, BA_WRAP);
//_pMainCharSprite->SetPosition(160, 160);
//_pGame->AddSprite(_pMainCharSprite);

// Play the background music
_pGame->PlayMIDISong(TEXT("Music.mid"));
}
}

BOOL is_open(int x,int y)
{
if(Mapa[x][y]._pBitmap==_pAguaBitmap) //compruebo si es agua.
{
return FALSE;
}

for(int a=0;a {
if(Monsters[a].x==x && Monsters[a].y==y) return FALSE;
}

if(MainChar.x==x && MainChar.y==y) return FALSE; //ésto es para los monstruos.

return TRUE;
}

BOOL is_near(int x,int y)
{
for(int a=MainChar.y-1;a<=MainChar.y+1;a++)
{
for(int b=MainChar.x-1;b<=MainChar.x+1;b++)
{
if(x==b && y==a) return TRUE;
}
}

return FALSE;
}

void UpdateBullets()
{
for(int a=0;a<_iNumberOfBullets;a++)
{
if(Bullets[a].x {
Bullets[a].x = Bullets[a].x + 20;
}
else
{
if(Bullets[a].x>Bullets[a].xdest) Bullets[a].x = Bullets[a].x - 20;
}
if(Bullets[a].y {
Bullets[a].y = Bullets[a].y + 20;
}
else
{
if(Bullets[a].y>Bullets[a].ydest) Bullets[a].y = Bullets[a].y - 20;
}
if(Bullets[a].x>(MainChar.x+5)*32 || Bullets[a].y>(MainChar.y+5)*32)
{
//Borrar la bala si se sale de los límites;
for(int b=a;b<_iNumberOfBullets;b++)
{
Bullets[b]=Bullets[b+1];
}
_iNumberOfBullets--;
}
else
{
if(Bullets[a].x>Bullets[a].xdest-10 && Bullets[a].xBullets[a].ydest-10 && Bullets[a].y {
//Borrar la bala si llega a su destino;
for(int b=a;b<_iNumberOfBullets;b++)
{
Bullets[b]=Bullets[b+1];
}
_iNumberOfBullets--;
}
}
}
}[/code]

Código fuente


Este tema ha sido archivado. Esto significa que no puedes responder en este tema.
publicidad
publicidad