554 lines
15 KiB
C++
554 lines
15 KiB
C++
/**************************************************************************\
|
||
|* *|
|
||
|* AVNTR_MM *|
|
||
|* *|
|
||
|* Descripci¢n: *|
|
||
|* M¢dulo principal de la aventura, y hasta el momento el *|
|
||
|* £nico. *|
|
||
|* *|
|
||
|* 1er Proyecto com£n entre Oscar y JD. ( 1§ de muchos ) *|
|
||
|* *|
|
||
|* Fecha: 12-06-97 00.58 / 01.34 *|
|
||
|* 10-07-97 13:05 / 14:07 *|
|
||
|* *|
|
||
\**************************************************************************/
|
||
|
||
#include <time.h>
|
||
|
||
|
||
#include <dos.h>
|
||
#include <mem.h>
|
||
#include <alloc.h>
|
||
#include <stdio.h>
|
||
|
||
#include "..\modex\modex.h"
|
||
|
||
|
||
#include <conio.h>
|
||
#include <stdlib.h>
|
||
|
||
#define OK 0
|
||
#define ERROR 1
|
||
|
||
#define CURSOR_NORMAL 1
|
||
|
||
|
||
char raton;
|
||
void Error(int code);
|
||
void Inicializa_Raton(int x1, int y1, int x2, int y2);
|
||
#define MEMORIA 1
|
||
|
||
|
||
class VirtualVGA
|
||
{
|
||
private:
|
||
long size, Planos, uPlano;
|
||
|
||
char huge *memVGA;
|
||
|
||
public:
|
||
long cX, cY;
|
||
|
||
VirtualVGA( long X, long Y );
|
||
~VirtualVGA() { delete[] memVGA; };
|
||
void copiaImagen( long offset, char huge *src, long size );
|
||
long Size( void ){ return size; };
|
||
void VGA(void);
|
||
|
||
char huge *memVirtual(void) { return memVGA; };
|
||
};
|
||
|
||
VirtualVGA::VirtualVGA( long X, long Y )
|
||
{
|
||
|
||
cY = Y; cX = X;
|
||
|
||
size = sizeof( char ) * Y * X;
|
||
if ( ( memVGA = new char huge[size] ) == NULL )
|
||
Error( MEMORIA );
|
||
|
||
// Calculamos el n§ de planos cortados que existen y el tama¤o del £ltimo
|
||
Planos = size / 0xFFFF;
|
||
uPlano = size % 0xFFFF;
|
||
|
||
};
|
||
|
||
void VirtualVGA::copiaImagen( long offset, char huge *src, long size )
|
||
{
|
||
char huge *dst;
|
||
// offset indica el comienzo dentro del bloque destino
|
||
// src puntero
|
||
|
||
dst = memVGA + offset;
|
||
while ( size-- ) *(dst++) = *(src++);
|
||
|
||
// _fmemcpy( dst, scr, size );
|
||
}
|
||
|
||
void VirtualVGA::VGA(void)
|
||
{
|
||
int i;
|
||
|
||
// for ( i=0; i<Planos; i++ )
|
||
draw_bitmap( (char far *)(memVGA + 0*0 ), 0, 0, cX, 150 );
|
||
draw_bitmap( (char far *)(memVGA +(150*360)), 0, 150, cX, 150 );
|
||
draw_bitmap( (char far *)(memVGA +(300*360)), 0, 300, 360, 100 );
|
||
};
|
||
|
||
void set_video_mode ( char mode )
|
||
{
|
||
asm {
|
||
mov AH, 0
|
||
mov AL, mode
|
||
int 0x10
|
||
}
|
||
};
|
||
|
||
void ControlPrincipal(void);
|
||
|
||
int CargaPaleta(char *file );
|
||
void CargaCursor( VirtualVGA **CursorN, VirtualVGA **CursorP, char TipoCursor );
|
||
void LiberaCursor( VirtualVGA **CursorN, VirtualVGA **CursorP );
|
||
void copiaBitmap( char huge *src, int cX, int cY, int wX, int wY, char huge *tgt );
|
||
|
||
void GetBitmap( char far *BitMapSRC, char far *TRG, int X, int Y, int Xw1, int Yw1, int Xw2 );
|
||
char far *CargaImagen( char *file, char huge *VGA, int cX, int cY );
|
||
|
||
long i = 0;
|
||
|
||
int main( void )
|
||
{
|
||
clock_t Start;
|
||
|
||
if (set_vga_modex( Mode_360x400, 360, 400, 1) == 0) Error(0x00);
|
||
|
||
Inicializa_Raton( 0, 0, 360-32, 400 );
|
||
// ancho del cursor ---------^
|
||
|
||
Start = clock();
|
||
ControlPrincipal();
|
||
Start = ( clock() - Start ) / CLK_TCK;
|
||
|
||
set_video_mode (3);
|
||
|
||
printf( "\n%ld segundos %ld planos y %ld planos por segundo\n", (long)Start, (long)i, (long)(i/Start) );
|
||
|
||
|
||
fflush( stdin );
|
||
return OK;
|
||
}
|
||
|
||
void GetBitmap( char far *BitMapSRC, char far *TRG, int X, int Y, int Xw1, int Yw1, int Xw2 )
|
||
{
|
||
int x, y;
|
||
|
||
for ( x = 0; x < Xw1; x++ )
|
||
for ( y = 0; y < Yw1; y++ )
|
||
*( TRG + x + y*Xw1 ) = *( BitMapSRC + X+x + (Y+y)*Xw2 );
|
||
}
|
||
|
||
|
||
void ControlPrincipal(void)
|
||
{
|
||
int oX, oY;
|
||
int X_Mouse, Y_Mouse;
|
||
union REGS io;
|
||
io.x.ax = 3;
|
||
char pCanim, nCanim;
|
||
|
||
pCanim = 0;
|
||
nCanim = 1;
|
||
|
||
VirtualVGA *CursorN, *CursorP;
|
||
CursorN = CursorP = NULL;
|
||
CargaCursor( &CursorN, &CursorP, CURSOR_NORMAL );
|
||
|
||
// Cuadro de Mandos
|
||
VirtualVGA cuadroMandos( 360, 100 );
|
||
CargaImagen( "control.pcx", cuadroMandos.memVirtual(), cuadroMandos.cX, cuadroMandos.cY );
|
||
// Dibujo del cuadro de mandos
|
||
draw_bitmap( (char far *)cuadroMandos.memVirtual(), 0, 300, cuadroMandos.cX, cuadroMandos.cY );
|
||
// CargaMuestraControles( cuadroMandos );
|
||
|
||
// VGA virtual, ( imprescindible volcarla )
|
||
VirtualVGA VGAvirtual( 360, 400 );
|
||
VirtualVGA FondoAvntr( 360, 300 );
|
||
CargaImagen( "boceto.pcx", FondoAvntr.memVirtual(), FondoAvntr.cX, FondoAvntr.cY );
|
||
|
||
CargaPaleta( "boceto.pcx" );
|
||
|
||
oX = oY = 0;
|
||
|
||
do {
|
||
|
||
// 1§ Rellenamos la virtual con los datos OK!
|
||
/**//**/ /**//**/ /**//**/ /**//**/ /**//**/
|
||
VGAvirtual.copiaImagen( 0, FondoAvntr.memVirtual(), FondoAvntr.Size() );
|
||
/*
|
||
copiaBitmap( FondoAvntr.memVGA, 0, 0, FondoAvntr.cX, FondoAvntr.cY, VGAvirtual.memVGA );
|
||
copiaBitmap( cuadroMandos.memVGA, 0, 300, cuadroMandos.cX, cuadroMandos.cY, VGAvirtual.memVGA );
|
||
*/
|
||
|
||
// 2§ Mostramos los £ltimos objetos de primer plano:
|
||
// ÚÄÄÄÄÄ¿ VGAvirtual
|
||
// ³ 1 ÚÄÁÄÄÄ¿ Objetos de 1er plano
|
||
// ÀÄÄÄ´ 2 ³
|
||
// ÀÄÄÄÄÄÙ
|
||
// Mostramos y controlamos el rat¢n ( redibujo de los controles y procesamiento de todo )
|
||
{
|
||
/*
|
||
if ( ( Y_Mouse + CursorP[ 0 ].cY ) >= 300 )
|
||
draw_bitmap( (char far *)cuadroMandos.memVGA, 0, 300, cuadroMandos.cX, cuadroMandos.cY );
|
||
*/
|
||
int86(0x33, &io, &io); // lee posici¢n y estados del bot¢n
|
||
X_Mouse = io.x.cx;
|
||
Y_Mouse = io.x.dx;
|
||
|
||
// Comprueba el tablero de control
|
||
// CompruebaMandos( X_Mouse, Y_Mouse, &cuadroMandos );
|
||
// Comprueba el resto de posibilidades ( el juego en s¡ )
|
||
|
||
// ¨ Se Puls¢ Un BOTON ?
|
||
// B.Izquierdo B. Derecho
|
||
if ( (io.x.bx & 1) != 0 || ( (io.x.bx >> 1) & 1 ) != 0 )
|
||
{
|
||
// copiaBitmap( CursorP[ pCanim ].memVirtual(), X_Mouse, Y_Mouse, CursorP[ pCanim ].cX, CursorP[ pCanim ].cY, VGAvirtual.memVirtual() );
|
||
copiaBitmap( CursorP[ pCanim ].memVirtual(), X_Mouse, Y_Mouse, 32, 32, VGAvirtual.memVirtual() );
|
||
// tdraw_bitmap( CursorP[ pCanim ].memVGA, X_Mouse, Y_Mouse, CursorP[ pCanim ].cX, CursorP[ pCanim ].cY );
|
||
} else {
|
||
// copiaBitmap( CursorN[ pCanim ].memVirtual(), X_Mouse, Y_Mouse, CursorN[ pCanim ].cX, CursorN[ pCanim ].cY, VGAvirtual.memVirtual() );
|
||
copiaBitmap( CursorN[ pCanim ].memVirtual(), X_Mouse, Y_Mouse, 32, 32, VGAvirtual.memVirtual() );
|
||
// tdraw_bitmap( CursorN[ pCanim ].memVGA, X_Mouse, Y_Mouse, CursorN[ pCanim ].cX, CursorN[ pCanim ].cY );
|
||
}
|
||
|
||
// Copiamos la virtual a la real...
|
||
// Partido por la mierda de la segmentaci¢n de la memoria
|
||
VGAvirtual.VGA();
|
||
}
|
||
|
||
i++;
|
||
} while ( !kbhit() );
|
||
|
||
LiberaCursor( &CursorN, &CursorP );
|
||
}
|
||
|
||
|
||
/**************************************************************************\
|
||
|* *|
|
||
|* CargaPaleta *|
|
||
|* *|
|
||
|* Descripci¢n: *|
|
||
|* Carga la paleta con los colores por defecto *|
|
||
|* *|
|
||
|* *|
|
||
|* Entradas: achivo PCX de donde cargar la paleta *|
|
||
|* *|
|
||
|* Salidas: OK Todo ha ido bien *|
|
||
|* ERROR Algo va mal *|
|
||
|* *|
|
||
\**************************************************************************/
|
||
int CargaPaleta(char *file )
|
||
{
|
||
int index;
|
||
FILE *fp;
|
||
|
||
if ( (fp=fopen( file, "rb" ) ) == NULL )
|
||
return ERROR;
|
||
|
||
|
||
if ( fseek( fp, -768L, SEEK_END ) == 0 )
|
||
{
|
||
for (index=0; index<256; index++)
|
||
{
|
||
// get the red component
|
||
// get the green component
|
||
// get the blue component
|
||
// set components
|
||
set_dac_register ( index, (getc(fp) >> 2), (getc(fp) >> 2), (getc(fp) >> 2) );
|
||
} // end for index
|
||
|
||
}
|
||
|
||
fclose( fp );
|
||
return OK;
|
||
}
|
||
|
||
|
||
|
||
/**************************************************************************\
|
||
|* *|
|
||
|* MuestraImagen *|
|
||
|* *|
|
||
|* Descripci¢n: *|
|
||
|* Descomprime y copia a la pagina indicada un PCX *|
|
||
|* *|
|
||
|* Entradas: nombre de la imagen *|
|
||
|* pagina *|
|
||
|* color_invisible ( -1 si ninguno ) *|
|
||
|* *|
|
||
|* *|
|
||
|* Salidas: OK Todo ha ido bien *|
|
||
|* ERROR Algo va mal *|
|
||
|* *|
|
||
\**************************************************************************/
|
||
int MuestraImagen( char *file, int page, int col_Inv )
|
||
{
|
||
int curr_page;
|
||
FILE *fp;
|
||
int alto, ancho, contador;
|
||
unsigned char byte;
|
||
|
||
|
||
if ( (fp = fopen( file,"rb")) != NULL )
|
||
{
|
||
|
||
curr_page = get_active_page();
|
||
set_active_page(page);
|
||
|
||
// Saltamos la cabecera
|
||
fseek( fp, 128, SEEK_SET );
|
||
|
||
for(alto=0; alto<240; alto++)
|
||
{
|
||
for(ancho=0; ancho<360; )
|
||
{
|
||
byte=getc(fp);
|
||
if(byte<=0xC0)
|
||
{
|
||
if ( col_Inv < 0 || byte != col_Inv ) set_point (ancho, alto, byte);
|
||
ancho++;
|
||
}
|
||
else
|
||
{
|
||
contador=byte&0x3F; byte=getc(fp);
|
||
for(; contador>0; contador--)
|
||
{
|
||
if ( col_Inv < 0 || byte != col_Inv ) set_point (ancho, alto, byte);
|
||
ancho++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
fclose(fp);
|
||
} else return ERROR;
|
||
|
||
set_active_page(curr_page);
|
||
|
||
return OK;
|
||
}
|
||
|
||
char far *CargaImagen( char *file, char huge *VGA, int cX, int cY )
|
||
{
|
||
int curr_page;
|
||
FILE *fp;
|
||
long alto, ancho, contador;
|
||
unsigned char byte;
|
||
|
||
if ( (fp = fopen( file,"rb")) != NULL )
|
||
{
|
||
|
||
// Saltamos la cabecera
|
||
fseek( fp, 128, SEEK_SET );
|
||
|
||
for(alto=0; alto<cY; alto++)
|
||
{
|
||
for(ancho=0; ancho<cX; )
|
||
{
|
||
byte=getc(fp);
|
||
if(byte<=0xC0)
|
||
{
|
||
*VGA = byte; VGA++;
|
||
// set_point( ancho, alto, *(emptyVGA.memVGA + alto*emptyVGA.cX + ancho) );
|
||
ancho++;
|
||
}
|
||
else
|
||
{
|
||
contador=byte&0x3F; byte=getc(fp);
|
||
for(; contador>0; contador--)
|
||
{
|
||
*VGA = byte; VGA ++;
|
||
// set_point( ancho, alto, *(emptyVGA.memVGA + alto*emptyVGA.cX + ancho) );
|
||
ancho++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
fclose(fp);
|
||
} else return NULL;
|
||
|
||
return VGA;
|
||
}
|
||
|
||
|
||
|
||
|
||
/**************************************************************************\
|
||
|* *|
|
||
|* Error *|
|
||
|* *|
|
||
|* Descripci¢n: *|
|
||
|* Aborta anormalmente el programa, mostrando un mensaje de *|
|
||
|* de error. *|
|
||
|* *|
|
||
|* Entradas: Codigo del mensaje de error a mostrar *|
|
||
|* Salidas: (ninguna) *|
|
||
|* *|
|
||
\**************************************************************************/
|
||
void Error(int code)
|
||
{
|
||
set_video_mode (3);
|
||
switch( code )
|
||
{
|
||
case MEMORIA:
|
||
printf( "Ni un byte libre para mi!\n");
|
||
break;
|
||
|
||
}
|
||
exit(code);
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
// los par metros son las cotas para el raton
|
||
void Inicializa_Raton(int x1, int y1, int x2, int y2)
|
||
{
|
||
|
||
// Por defecto el raton aparecer en las coordenadas ( 50, 50 )
|
||
int px = 50, py = 50;
|
||
|
||
// Pero si Y_ y X_ tienen unas coordenadas el raton se posiciona alli.
|
||
/*
|
||
if ( Y_Mouse != -1 && X_Mouse != -1 )
|
||
{
|
||
px = X_Mouse; py = Y_Mouse;
|
||
}
|
||
*/
|
||
union REGS ent, sal;
|
||
long dir;
|
||
|
||
ent.x.ax = 0;
|
||
int86(0x33, &ent, &sal); /* averigua si hay rat¢n conectado */
|
||
|
||
raton = sal.x.ax; /* indica a la variable global el estado
|
||
del raton */
|
||
|
||
if(raton!=0) {
|
||
|
||
ent.x.ax = 15;
|
||
ent.x.cx = 5;
|
||
ent.x.dx = 11;
|
||
int86(0x33, &ent, &sal); /* fija la raz¢n mickey/pixel */
|
||
|
||
ent.x.ax = 7;
|
||
ent.x.cx = x1;
|
||
ent.x.dx = x2;
|
||
int86(0x33, &ent, &sal); /* fija la posici¢n m x. y m¡n. horizontal */
|
||
|
||
ent.x.ax = 8;
|
||
ent.x.cx = y1;
|
||
ent.x.dx = y2;
|
||
int86(0x33, &ent, &sal); /* fija la posici¢n m x. y m¡n. vertical */
|
||
|
||
ent.x.ax = 4;
|
||
ent.x.cx = px;
|
||
ent.x.dx = py;
|
||
int86(0x33, &ent, &sal); /* fija la posici¢n del rat¢n */
|
||
|
||
ent.x.ax = 2; // Como sabes hacer esto, no sirve para nada
|
||
int86(0x33, &ent, &ent); // por que el raton no se puede mostrar y por
|
||
// deducion, tan poco ocultar.
|
||
// Pero " Por si el modo no es SVGA ", lo ocultamos
|
||
|
||
}
|
||
}
|
||
|
||
void LiberaCursor( VirtualVGA **CursorN, VirtualVGA **CursorP )
|
||
{
|
||
/*
|
||
int i;
|
||
|
||
if ( (*CursorP) != NULL )
|
||
{
|
||
for ( i=0; i<10; i++ )
|
||
EliminaVirtual( &((*CursorP)[i]) );
|
||
|
||
free( (*CursorP) );
|
||
}
|
||
|
||
if ( (*CursorN) != NULL )
|
||
{
|
||
for ( i=0; i<10; i++ )
|
||
EliminaVirtual( &((*CursorN)[i]) );
|
||
|
||
free( (*CursorN) );
|
||
}
|
||
*/
|
||
}
|
||
|
||
void CargaCursor( VirtualVGA **CursorN, VirtualVGA **CursorP, char TipoCursor )
|
||
{
|
||
/*
|
||
int i;
|
||
|
||
// El cursor presionado solo se carga una vez ( siempre es el mismo )
|
||
if ( (*CursorP) == NULL )
|
||
{
|
||
// cargamos el cursor animado ( presionado ) :: 10 animaciones ::
|
||
if ( ( (*CursorP) = (VirtualVGA *)malloc( sizeof(VirtualVGA)*10 ) ) == NULL )
|
||
Error( 0x00 );
|
||
|
||
for ( i=0; i<10; i++ )
|
||
{
|
||
// CURSOR PRESIONADO: 32x32
|
||
(*CursorP)[i].cX = 32; (*CursorP)[i].cY = 32;
|
||
CreaVirtual( &((*CursorP)[i]) );
|
||
}
|
||
}
|
||
|
||
if ( (*CursorN) == NULL )
|
||
{
|
||
// cargamos el cursor animado ( liberado ) :: 10 animaciones ::
|
||
if ( ( (*CursorN) = (VirtualVGA *)malloc( sizeof(VirtualVGA)*10 ) ) == NULL )
|
||
Error( 0x00 );
|
||
|
||
for ( i=0; i<10; i++ )
|
||
{
|
||
// CURSOR PRESIONADO: 32x32
|
||
(*CursorN)[i].cX = 32; (*CursorN)[i].cY = 32;
|
||
CreaVirtual( &((*CursorN)[i]) );
|
||
}
|
||
}
|
||
|
||
switch( TipoCursor )
|
||
{
|
||
case CURSOR_NORMAL:
|
||
default:
|
||
for ( i=0; i<10; i++ )
|
||
{
|
||
// CURSOR PRESIONADO: 32x32
|
||
}
|
||
break;
|
||
}
|
||
*/
|
||
}
|
||
|
||
|
||
void copiaBitmap( char huge *src, int cX, int cY, int wX, int wY, char huge *tgt )
|
||
{
|
||
long i; char c;
|
||
long offY;
|
||
|
||
wY = (cY + wY); wY = wY >= 400 ? 400 : wY;
|
||
wX = (cX + wX); wX = wX >= 360 ? 360 : wX;
|
||
|
||
for ( ; cY < wY; cY++ )
|
||
{
|
||
offY = (long)cY*360;
|
||
for ( i = cX; i < wX; i++ )
|
||
if ( ( c = *(src++) ) != 0 )
|
||
*(tgt + offY + i ) = c;
|
||
}
|
||
}
|