736 lines
16 KiB
C
736 lines
16 KiB
C
|
||
#include "c_extern.h"
|
||
|
||
#include <stdlib.h>
|
||
#include <stdio.h>
|
||
#include <dos.h>
|
||
#include <i86.h>
|
||
|
||
#include "grille.h"
|
||
|
||
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
|
||
Ûßßßß ÛßßßÛ Û Û Û Ûßßßß
|
||
ÛÛ ßÛ ÛÛßÛß ÛÛ ÛÛ ÛÛ ÛÛßß
|
||
ßßßßß ßß ß ßß ßßßßß ßßßßß ßßßßß
|
||
*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
|
||
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
|
||
|
||
#define HEADER_BLOCK 3
|
||
|
||
#define DXBLOCK 0
|
||
#define DYBLOCK 1
|
||
#define DZBLOCK 2
|
||
|
||
/*-------------------------------------------------------------------------*/
|
||
/* prototype */
|
||
|
||
UBYTE *GetAdrBlock( LONG numblock ) ;
|
||
UBYTE GetColBrick( WORD xm, WORD ym, WORD zm ) ;
|
||
ULONG CreateMaskGph( UBYTE *pt, UBYTE *dest ) ;
|
||
/*-------------------------------------------------------------------------*/
|
||
|
||
LONG StartXCube = 0 ;
|
||
LONG StartYCube = 0 ;
|
||
LONG StartZCube = 0 ;
|
||
|
||
LONG WorldXCube = 0 ;
|
||
LONG WorldYCube = 0 ;
|
||
LONG WorldZCube = 0 ;
|
||
|
||
WORD XpOrgw ;
|
||
WORD YpOrgw ;
|
||
|
||
#define NB_COLON 28
|
||
#define MAX_BRICK 150
|
||
|
||
WORD NbBrickColon[NB_COLON] ;
|
||
|
||
typedef struct
|
||
{
|
||
WORD Xm ;
|
||
WORD Ym ;
|
||
WORD Zm ;
|
||
WORD Ys ;
|
||
WORD Brick ;
|
||
|
||
} T_COLONB ;
|
||
|
||
T_COLONB ListBrickColon[NB_COLON][MAX_BRICK] ;
|
||
|
||
UBYTE *BufCube = 0 ;
|
||
UBYTE *BufMap = 0 ;
|
||
UBYTE *TabBlock ;
|
||
UBYTE *BufferBrick ;
|
||
|
||
UBYTE *BufferMaskBrick ;
|
||
|
||
LONG XMap, YMap, ZMap ;
|
||
LONG NbBlock ;
|
||
LONG XScreen, YScreen ;
|
||
|
||
LONG DxBlock, DyBlock, DzBlock;
|
||
|
||
//LONG CoulFond=0 ;
|
||
|
||
extern WORD Nxw, Nyw, Nzw ;
|
||
void ReajustPos( UBYTE col ) ;
|
||
/*--------------------------------------------------------------------------*/
|
||
#ifdef BRICK_HQR
|
||
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
|
||
Û Û ÛßßßÛ ÛßßßÛ ÛßßÛ ÛßßßÛ Û Ûßßßß Û Üß
|
||
ÛÛßßÛ ÛÛ ÜÛ ÛÛßÛß ÛÛßßÛ ÛÛßÛß ÛÛ ÛÛ ÛÛßÜ
|
||
ßß ß ßßßß ßß ß ßßßßß ßßßßß ßß ß ßß ßßßßß ßß ß
|
||
*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
|
||
#define MAX_BRICK_GAME 10000L
|
||
#define OFFSET_BUFFER_FLAG 153800L
|
||
|
||
char *NameHqrGri=PATH_RESSOURCE"LBA_GRI.HQR" ;
|
||
char *NameHqrBll=PATH_RESSOURCE"LBA_BLL.HQR" ;
|
||
char *NameHqrBrk=PATH_RESSOURCE"LBA_BRK.HQR" ;
|
||
|
||
typedef struct { ULONG SizeFile ;
|
||
ULONG CompressedSizeFile ;
|
||
WORD CompressMethod ; /* 0 stored */
|
||
/* 1 LZS */
|
||
} T_HEADER ;
|
||
|
||
/*--------------------------------------------------------------------------*/
|
||
LONG LoadUsedBrick( ULONG size )
|
||
{
|
||
ULONG i, j, b ;
|
||
UBYTE *pt ;
|
||
UBYTE *ptb ;
|
||
UWORD *ptw ;
|
||
ULONG *ptoff ;
|
||
UBYTE *ptdata ;
|
||
UBYTE *ptsrc ;
|
||
UBYTE *ptused ;
|
||
ULONG offset ;
|
||
ULONG maxbrk ;
|
||
ULONG nbbrick ;
|
||
ULONG brick ;
|
||
ULONG offseek ;
|
||
ULONG *ptseek ;
|
||
ULONG handle ;
|
||
ULONG nbentity;
|
||
UWORD *tabflag;
|
||
UWORD *ptflag ;
|
||
UWORD min, max;
|
||
T_HEADER header ;
|
||
UBYTE *ptdecomp ;
|
||
|
||
tabflag = (UWORD*)(Screen+OFFSET_BUFFER_FLAG) ;
|
||
|
||
RazMem( tabflag, MAX_BRICK_GAME*2L ) ;/* Table de UWORD pour NewNumBrick */
|
||
|
||
min = 60000 ;
|
||
max = 0 ;
|
||
|
||
/*-------------------------------------- Premiere Passe, Pr‚paration ptflag */
|
||
|
||
pt = ptused = BufMap+(size-32) ;/* Debut de Used Block */
|
||
|
||
for ( i = 1 ; i < 256 ; i++ )
|
||
{
|
||
b = pt[i>>3] & (1<<(7-(i&7))) ;/* Recup Bit Block */
|
||
if ( !b ) continue ;
|
||
|
||
ptb = TabBlock + *(ULONG *)(TabBlock+((i-1)<<2));
|
||
ptw = (UWORD *)(ptb + 5) ;/* Jump dx dy dz et collis */
|
||
maxbrk = *ptb * *(ptb+1) * *(ptb+2) ;/* dx*dy*dz*/
|
||
|
||
for ( j = 0 ; j < maxbrk ; j++, ptw += 2 )
|
||
{
|
||
brick = *ptw ;
|
||
|
||
if ( brick )
|
||
{
|
||
brick-- ;
|
||
|
||
if ( brick < min ) min = brick ;
|
||
if ( brick > max ) max = brick ;
|
||
|
||
tabflag[brick] = 1 ;
|
||
}
|
||
}
|
||
}
|
||
|
||
/*-------------------------------------- Deuxieme Passe, On compte les Bricks*/
|
||
ptflag = tabflag+min ;
|
||
|
||
nbbrick = 0 ;
|
||
|
||
for ( i = min ; i <= max ; i++, ptflag++ )
|
||
{
|
||
if ( *ptflag ) nbbrick++ ;
|
||
}
|
||
|
||
/*-------------------------------------- Troisieme Passe, Load Brick */
|
||
|
||
handle = OpenRead( NameHqrBrk ) ;
|
||
if ( !handle ) return(0L) ;
|
||
|
||
Read( handle, &nbentity, 4L ) ;
|
||
Seek( handle, 0L, SEEK_START ) ;
|
||
|
||
Read( handle, Screen, nbentity );
|
||
nbentity >>= 2 ;
|
||
|
||
ptflag = tabflag+min ;
|
||
|
||
ptoff = (ULONG *)BufferBrick ;
|
||
|
||
offset = (nbbrick+1)*4L ;
|
||
|
||
*ptoff++ = offset ;/* First Offset */
|
||
|
||
ptdata = BufferBrick+offset ;/* Jump nbbrick+1 Offset */
|
||
|
||
nbbrick = 0 ;
|
||
|
||
ptseek = (ULONG *)Screen ;
|
||
|
||
for ( i = min ; i <= max ; i++, ptflag++ )
|
||
{
|
||
if ( *ptflag )
|
||
{
|
||
nbbrick++ ;/* One More*/
|
||
*ptflag = nbbrick ;/* Brick+1 */
|
||
offseek = *(ptseek+i) ;
|
||
Seek( handle, offseek, SEEK_START ) ;
|
||
Read( handle, &header, sizeof(header)) ;
|
||
switch( header.CompressMethod )
|
||
{
|
||
case 0:
|
||
Read( handle, ptdata, header.SizeFile ) ;
|
||
break ;
|
||
case 1:
|
||
ptdecomp = ptdata+header.SizeFile-header.CompressedSizeFile+500 ;
|
||
Read( handle, ptdecomp, header.CompressedSizeFile ) ;
|
||
Expand( ptdecomp, ptdata, header.SizeFile ) ;
|
||
break ;
|
||
}
|
||
ptdata += header.SizeFile ;
|
||
offset += header.SizeFile ;
|
||
*ptoff++ = offset ;
|
||
}
|
||
}
|
||
|
||
/*-------------------------------------- Quatrieme Passe, Rename Block */
|
||
|
||
pt = ptused ;/* Debut de Used Block */
|
||
|
||
for ( i = 1 ; i < 256 ; i++ )
|
||
{
|
||
b = pt[i>>3] & (1<<(7-(i&7))) ;/* Recup Bit Block */
|
||
if ( !b ) continue ;
|
||
|
||
ptb = TabBlock + *(ULONG *)(TabBlock+((i-1)<<2));
|
||
ptw = (UWORD *)(ptb + 5) ;/* Jump dx dy dz et collis */
|
||
maxbrk = *ptb * *(ptb+1) * *(ptb+2) ;/* dx*dy*dz*/
|
||
|
||
for ( j = 0 ; j < maxbrk ; j++, ptw += 2 )
|
||
{
|
||
if ( *ptw ) *ptw = tabflag[(*ptw)-1];
|
||
}
|
||
}
|
||
|
||
Close(handle) ;
|
||
|
||
return(offset) ;
|
||
}
|
||
/*-------------------------------------------------------------------------*/
|
||
LONG InitGrille( UWORD numcube )
|
||
{
|
||
ULONG i, b, j ;
|
||
UBYTE *pt ;
|
||
ULONG sizegri ;
|
||
ULONG sizebll ;
|
||
ULONG size ;
|
||
|
||
// BufCube = Malloc(SIZE_CUBE_X*SIZE_CUBE_Y*SIZE_CUBE_Z*2L ) ;
|
||
// if ( BufCube == 0L ) return(0L) ;
|
||
|
||
sizegri = Size_HQR( NameHqrGri, numcube ) ;/* GRI */
|
||
HQM_Alloc( sizegri, &BufMap ) ;
|
||
CHECK_MEMORY
|
||
// BufMap = Malloc( sizegri+500 ) ;
|
||
if ( BufMap == 0L ) return(0L) ;
|
||
Load_HQR( NameHqrGri, BufMap, numcube ) ;
|
||
// Mshrink( BufMap, sizegri ) ;
|
||
|
||
sizebll = Size_HQR( NameHqrBll, numcube ) ;/* BLL */
|
||
HQM_Alloc( sizebll, &TabBlock ) ;
|
||
CHECK_MEMORY
|
||
// TabBlock = Malloc( sizebll+500 ) ; bordel !
|
||
if ( TabBlock == 0L ) return(0L) ;
|
||
Load_HQR( NameHqrBll, TabBlock, numcube ) ;
|
||
// Mshrink( TabBlock, sizebll ) ;
|
||
|
||
/*---------------------------------------------- NEW */
|
||
/* Message("Loading Brick, Please Wait...", FALSE );*/
|
||
|
||
size = LoadUsedBrick( sizegri ) ;
|
||
if ( !size ) return(0L) ;
|
||
|
||
/* Message(" End Loading Brick ", FALSE );*/
|
||
/*----------------------------------------------*/
|
||
|
||
HQM_Alloc( size, &BufferMaskBrick ) ;
|
||
size = CreateMaskGph( BufferBrick, BufferMaskBrick ) ;
|
||
HQM_Shrink_Last( BufferMaskBrick, size ) ;
|
||
CHECK_MEMORY
|
||
|
||
/* BufferMaskBrick = Malloc( size ) ;
|
||
size = CreateMaskGph( BufferBrick, BufferMaskBrick ) ;
|
||
Mshrink( BufferMaskBrick, size ) ;// Reduc no test
|
||
*/
|
||
NbBlock = (*(ULONG*)TabBlock)/4 ;
|
||
|
||
CopyMapToCube() ;
|
||
|
||
return(1L) ;
|
||
}
|
||
/*--------------------------------------------------------------------------*/
|
||
void FreeGrille()
|
||
{
|
||
/* if( BufMap )
|
||
{
|
||
Free( BufferMaskBrick ) ;
|
||
Free( TabBlock ) ;
|
||
Free( BufMap ) ;
|
||
// Free( BufCube ) ;
|
||
|
||
BufMap = 0 ;
|
||
}
|
||
*/
|
||
}
|
||
/*-------------------------------------------------------------------------*/
|
||
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
|
||
Ûßßßß ÛÛÜ Û ÛßßßÜ Û Û ÛßßßÛ ÛßßßÛ
|
||
ÛÛßß ÛÛßÛÛ ÛÛ Û ÛÛßßÛ ÛÛ ÜÛ ÛÛßÛß
|
||
ßßßßß ßß ß ßßßß ßß ß ßßßß ßß ß
|
||
*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
|
||
#endif
|
||
/*--------------------------------------------------------------------------*/
|
||
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
|
||
Ûßßßß Û Û ÛÛÜ Û Ûßßßß ßßÛßß Û ÛßßßÛ ÛÛÜ Û ÛÛßßß
|
||
ÛÛßß ÛÛ Û ÛÛßÛÛ ÛÛ ÛÛ ÛÛ ÛÛ Û ÛÛßÛÛ ßßßßÛ
|
||
ßß ßßßßß ßß ß ßßßßß ßß ßß ßßßßß ßß ß ßßßßß
|
||
*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
|
||
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
|
||
|
||
/*--------------------------------------------------------------------------*/
|
||
UBYTE *GetAdrColonneMap( LONG x, LONG z )
|
||
{
|
||
ULONG offset ;
|
||
|
||
offset = (x+(z*SIZE_CUBE_Z))*2 ;
|
||
offset = *(UWORD*)(BufMap+offset ) ;
|
||
|
||
return(BufMap+offset) ;
|
||
}
|
||
/*--------------------------------------------------------------------------*/
|
||
UBYTE *GetAdrColonneCube( LONG x, LONG z )
|
||
{
|
||
ULONG offset ;
|
||
|
||
offset = (x*SIZE_CUBE_Y*2)+(z*SIZE_CUBE_Z*SIZE_CUBE_Y*2);
|
||
|
||
return(BufCube+offset) ;
|
||
}
|
||
|
||
/*--------------------------------------------------------------------------*/
|
||
|
||
void GetShadow( WORD xw, WORD yw, WORD zw )
|
||
{
|
||
WORD xm, ym, zm ;
|
||
UBYTE *ptc ;
|
||
WORD y ;
|
||
UBYTE *adr ;
|
||
LONG block ;
|
||
|
||
xm = (xw+DEMI_BRICK_XZ)/SIZE_BRICK_XZ ;
|
||
ym = yw/SIZE_BRICK_Y ;
|
||
zm = (zw+DEMI_BRICK_XZ)/SIZE_BRICK_XZ ;
|
||
|
||
ptc = BufCube + ym*2 + (xm*SIZE_CUBE_Y*2) + (zm*SIZE_CUBE_X*SIZE_CUBE_Y*2) ;
|
||
|
||
for( y = ym; y>0; y-- )
|
||
{
|
||
if( *(WORD*)ptc != 0 ) break ;
|
||
ptc -= 2 ;
|
||
}
|
||
|
||
XMap = xm ;
|
||
YMap = y ;
|
||
ZMap = zm ;
|
||
|
||
Nxw = xw ;
|
||
Nyw = (y+1) * SIZE_BRICK_Y ;
|
||
Nzw = zw ;
|
||
|
||
ShadowCol = 0 ;
|
||
|
||
if( *ptc != 0 )
|
||
{
|
||
block = (*ptc++) - 1 ;
|
||
adr = GetAdrBlock( block ) ;
|
||
adr += HEADER_BLOCK ;
|
||
adr += (*ptc)<<2 ;/* 4 Bytes to Jump */
|
||
ShadowCol = *adr ;
|
||
ReajustPos( ShadowCol ) ;
|
||
/* ShadowCol-- ; *//* pour num gph */
|
||
}
|
||
|
||
ShadowX = Nxw ;
|
||
ShadowY = Nyw ;
|
||
ShadowZ = Nzw ;
|
||
}
|
||
|
||
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
|
||
|
||
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
|
||
ÛÜ ÜÛ Ûßßßß ÛÜ ÜÛ ÛßßßÛ Û ÛßßßÛ Ûßßßß
|
||
ÛÛß Û ÛÛßß ÛÛß Û ÛÛ Û ÛÛ ÛÛßÛß ÛÛßß
|
||
ßß ß ßßßßß ßß ß ßßßßß ßß ßß ß ßßßßß
|
||
*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
|
||
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
|
||
|
||
ULONG CreateMaskGph( UBYTE *ptsrc, UBYTE *ptdst )
|
||
{
|
||
UBYTE *ptd ;
|
||
ULONG nbg, off;
|
||
ULONG *ptoff ;
|
||
ULONG size, i ;
|
||
|
||
ptoff = (ULONG*)ptdst ;
|
||
|
||
off = *(ULONG *)ptsrc ;/* First Offset Src */
|
||
|
||
*ptoff++ = off ;/* First Offset */
|
||
|
||
ptd = ptdst+off ;
|
||
|
||
nbg = (off-4)>>2 ;/* Nombre de Graph */
|
||
|
||
for ( i = 0 ; i < nbg ; i++ )
|
||
{
|
||
size = CalcGraphMsk( i, ptsrc, ptd ) ;
|
||
|
||
off += size ;/* Maj Offset */
|
||
*ptoff++ = off ;/* Write Offset */
|
||
ptd += size ;/* Maj Pt Dest */
|
||
}
|
||
return(off) ;
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------*/
|
||
void MixteMapToCube( UBYTE *map )
|
||
{
|
||
UBYTE *ptb ;
|
||
LONG blk, pos, nb ;
|
||
UBYTE *pts, *ptd ;
|
||
LONG x, y, z ;
|
||
ULONG offset, flg=1 ;
|
||
|
||
for ( z = 0 ; z < SIZE_CUBE_Z ; z++ )
|
||
{
|
||
for ( x = 0 ; x < SIZE_CUBE_X ; x++ )
|
||
{
|
||
offset = (x+(z*SIZE_CUBE_Z))*2 ;
|
||
offset = *(UWORD*)(map+offset ) ;
|
||
|
||
pts = map+offset ;
|
||
ptd = GetAdrColonneCube( x, z ) ;
|
||
MixteColonne( pts, ptd ) ;
|
||
}
|
||
}
|
||
}
|
||
/*--------------------------------------------------------------------------*/
|
||
void CopyMapToCube()
|
||
{
|
||
UBYTE *pts, *ptd, *ptb ;
|
||
LONG x, y, z, blk, pos, nb ;
|
||
LONG flg=1 ;
|
||
|
||
/*-------------- Copy -------------------------*/
|
||
for ( z = 0 ; z < SIZE_CUBE_Z ; z++ )
|
||
{
|
||
for ( x = 0 ; x < SIZE_CUBE_X ; x++ )
|
||
{
|
||
pts = GetAdrColonneMap( x, z ) ;
|
||
ptd = GetAdrColonneCube( x, z ) ;
|
||
DecompColonne( pts, ptd ) ;
|
||
}
|
||
}
|
||
}
|
||
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
|
||
|
||
void InitBufferCube()
|
||
{
|
||
BufCube = Malloc(SIZE_CUBE_X*SIZE_CUBE_Y*SIZE_CUBE_Z*2L ) ;
|
||
if ( BufCube == 0L )
|
||
TheEnd( NOT_ENOUGH_MEM, "BufCube" ) ;
|
||
|
||
// Init Buffer Brick
|
||
BufferBrick = Malloc(MAX_SIZE_BRICK_CUBE) ;
|
||
if ( BufferBrick == 0L )
|
||
TheEnd( NOT_ENOUGH_MEM, "BufferBrick" ) ;
|
||
}
|
||
|
||
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
|
||
ÛßßßÜ Û ÛÛßßß ÛßßßÛ Û ÛßßßÛ Û Üß
|
||
ÛÛ Û ÛÛ ßßßßÛ ÛÛßßß ÛÛ ÛÛßßÛ ÛÛß
|
||
ßßßß ßß ßßßßß ßß ßßßßß ßß ß ßß
|
||
*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
|
||
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
|
||
|
||
void DrawOverBrick( WORD xm, WORD ym, WORD zm )
|
||
{
|
||
T_COLONB *ptrlbc ;
|
||
WORD col, i ;
|
||
WORD startcol, endcol ;
|
||
|
||
startcol = (ClipXmin+24)/24-1 ;
|
||
endcol = (ClipXmax+24)/24 ;
|
||
|
||
for( col = startcol; col <= endcol; col++ )
|
||
{
|
||
ptrlbc = &ListBrickColon[col][0] ;
|
||
|
||
for( i=0; i<NbBrickColon[col]; i++ )
|
||
{
|
||
/* bricks devant */
|
||
if( ptrlbc->Ys+38 > ClipYmin
|
||
AND ptrlbc->Ys <= ClipYmax )
|
||
{
|
||
if( ptrlbc->Ym >= ym )
|
||
{
|
||
if( (ptrlbc->Xm+ptrlbc->Zm) > (xm+zm) )
|
||
{
|
||
CopyMask( ptrlbc->Brick, col*24-24, ptrlbc->Ys, BufferMaskBrick, Screen ) ;
|
||
}
|
||
}
|
||
}
|
||
ptrlbc++ ;
|
||
}
|
||
}
|
||
}
|
||
|
||
/*--------------------------------------------------------------------------*/
|
||
/*
|
||
void DrawOverBrick2( WORD xm, WORD ym, WORD zm )
|
||
{
|
||
T_COLONB *ptrlbc ;
|
||
WORD col, i ;
|
||
WORD startcol, endcol ;
|
||
|
||
startcol = (ClipXmin+24)/24-1 ;
|
||
endcol = (ClipXmax+24)/24 ;
|
||
|
||
for( col = startcol; col <= endcol; col++ )
|
||
{
|
||
ptrlbc = &ListBrickColon[col][0] ;
|
||
|
||
for( i=0; i<NbBrickColon[col]; i++ )
|
||
{
|
||
if( ptrlbc->Ys+38 > ClipYmin
|
||
AND ptrlbc->Ys <= ClipYmax )
|
||
{
|
||
if( ptrlbc->Ym >= ym )
|
||
{
|
||
if( (ptrlbc->Zm >= zm)
|
||
AND (ptrlbc->Xm >= xm) )
|
||
{
|
||
CopyMask( ptrlbc->Brick, col*24-24, ptrlbc->Ys, BufferMaskBrick, Screen ) ;
|
||
}
|
||
|
||
}
|
||
}
|
||
ptrlbc++ ;
|
||
}
|
||
}
|
||
}
|
||
*/
|
||
/*--------------------------------------------------------------------------*/
|
||
/* recouvrement reel pour obj qui ne depassent pas la ZV */
|
||
|
||
void DrawOverBrick3( WORD xm, WORD ym, WORD zm )
|
||
{
|
||
T_COLONB *ptrlbc ;
|
||
WORD col, i ;
|
||
WORD startcol, endcol ;
|
||
|
||
startcol = (ClipXmin+24)/24-1 ;
|
||
endcol = (ClipXmax+24)/24 ;
|
||
|
||
for( col = startcol; col <= endcol; col++ )
|
||
{
|
||
ptrlbc = &ListBrickColon[col][0] ;
|
||
|
||
for( i=0; i<NbBrickColon[col]; i++ )
|
||
{
|
||
/* bricks devant */
|
||
if( ptrlbc->Ys+38 > ClipYmin
|
||
AND ptrlbc->Ys <= ClipYmax )
|
||
{
|
||
if( ptrlbc->Ym >= ym )
|
||
{
|
||
|
||
if( (ptrlbc->Zm == zm)
|
||
AND (ptrlbc->Xm == xm) )
|
||
{
|
||
CopyMask( ptrlbc->Brick, col*24-24, ptrlbc->Ys, BufferMaskBrick, Screen ) ;
|
||
}
|
||
|
||
if( (ptrlbc->Zm > zm)
|
||
OR (ptrlbc->Xm > xm) )
|
||
{
|
||
CopyMask( ptrlbc->Brick, col*24-24, ptrlbc->Ys, BufferMaskBrick, Screen ) ;
|
||
}
|
||
|
||
}
|
||
}
|
||
ptrlbc++ ;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/*--------------------------------------------------------------------------*/
|
||
void AffBrickBlock( LONG block, LONG brick, LONG x, LONG y, LONG z )
|
||
{
|
||
UBYTE *adr ;
|
||
LONG numbrick;
|
||
LONG nb, col ;
|
||
WORD bc ;
|
||
|
||
adr = GetAdrBlock( block ) ;
|
||
adr += HEADER_BLOCK ;
|
||
|
||
adr += ( brick<<2 ) ;/* 4 Bytes to Jump */
|
||
adr += 2 ;
|
||
|
||
numbrick = *(UWORD*)adr ; /* & 32767 */
|
||
|
||
if ( numbrick )
|
||
{
|
||
Map2Screen( x-StartXCube, y-StartYCube, z-StartZCube ) ;
|
||
|
||
if( XScreen >= -24
|
||
AND XScreen < 640
|
||
AND YScreen >= -38
|
||
AND YScreen < 480 )
|
||
{
|
||
AffGraph( numbrick-1, XScreen, YScreen, BufferBrick ) ;
|
||
|
||
col = (XScreen+24)/24 ; /* 48 / 2 colonne intercal‚e */
|
||
|
||
nb = NbBrickColon[col] ;
|
||
if( nb < MAX_BRICK )
|
||
{
|
||
// ca moche mettre PTR
|
||
|
||
ListBrickColon[ col ][ nb ].Xm = x ;
|
||
ListBrickColon[ col ][ nb ].Ym = y ;
|
||
ListBrickColon[ col ][ nb ].Zm = z ;
|
||
ListBrickColon[ col ][ nb ].Ys = YScreen ;
|
||
ListBrickColon[ col ][ nb ].Brick = numbrick-1 ;
|
||
NbBrickColon[ col ]++ ;
|
||
|
||
}
|
||
else
|
||
Message( "Arg MAX_BRICK Z BUFFER atteint", TRUE ) ;
|
||
}
|
||
}
|
||
}
|
||
|
||
/*--------------------------------------------------------------------------*/
|
||
/*ptc = BufCube + y*2 + (x*SIZE_CUBE_Y*2) + (z*SIZE_CUBE_X*SIZE_CUBE_Y*2) ;*/
|
||
|
||
void AffGrille()
|
||
{
|
||
LONG z, y, x ;
|
||
LONG block ;
|
||
UBYTE *ptc ;
|
||
|
||
WorldXCube = StartXCube*SIZE_BRICK_XZ ;
|
||
WorldYCube = StartYCube*SIZE_BRICK_Y ;
|
||
WorldZCube = StartZCube*SIZE_BRICK_XZ ;
|
||
|
||
ProjettePoint( -WorldXCube, -WorldYCube, -WorldZCube ) ;
|
||
XpOrgw = Xp ;
|
||
YpOrgw = Yp ;
|
||
|
||
for( x=0; x<NB_COLON; x++ ) NbBrickColon[x] = 0 ;
|
||
|
||
if( !FlagAffGrille ) return ;
|
||
|
||
ptc = BufCube ;
|
||
for ( z = 0 ; z < SIZE_CUBE_Z ; z++ )
|
||
{
|
||
for ( x = 0 ; x < SIZE_CUBE_X ; x++ )
|
||
{
|
||
for ( y = 0 ; y < SIZE_CUBE_Y ; y++ )
|
||
{
|
||
block = *ptc++ ;
|
||
|
||
if ( block )
|
||
{
|
||
AffBrickBlock( block-1, *ptc, x, y, z ) ;
|
||
}
|
||
ptc++ ;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* y = 0 ;
|
||
for( x=0; x<NB_COLON; x++ )
|
||
{
|
||
Text( 0,y, "%l", NbBrickColon[x] ) ;
|
||
y += 8 ;
|
||
}
|
||
*/
|
||
|
||
|
||
}
|
||
|
||
void IncrustGrm( WORD numgrm )
|
||
{
|
||
UBYTE *ptrgrm ;
|
||
|
||
ptrgrm = LoadMalloc_HQR(PATH_RESSOURCE"lba_gri.hqr",
|
||
numgrm + OFFSET_GRM_HQR ) ;
|
||
if( !ptrgrm )
|
||
{
|
||
Message( "arg grm not found in lba_gri", TRUE ) ;
|
||
return ;
|
||
}
|
||
|
||
MixteMapToCube( ptrgrm ) ;
|
||
|
||
Free( ptrgrm ) ;
|
||
|
||
FirstTime = TRUE ;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|