lib/lba1-classic
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Gwen Gourevich
2021-10-27 10:34:18 +02:00
parent 43ad18eb04
commit c5f4f6ba25
199 changed files with 73169 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

244
SOURCES/ADFLI_A.ASM Normal file
View File

@@ -0,0 +1,244 @@
;----------------------------------------------------------------------------
;
;' ADFLI.ASM 386
;' (c) Adeline 1994
;
;----------------------------------------------------------------------------
.386P
.model SMALL, SYSCALL
;----------------------------------------------------------------------------
.data
;----------------------------------------------------------------------------
include \projet\lib386\lib_svga\svga.ash
;----------------------------------------------------------------------------
.code
public NoLanguage DrawFrame
public NoLanguage UpdateFrame
public NoLanguage BlackFrame
public NoLanguage CopyFrame
; public NoLanguage SetPal
; public NoLanguage CpyPal
;----------------------------------------------------------------------------
DrawFrame proc uses esi edi ebx,\
ptframe:DWORD, deltax:DWORD, deltay:DWORD
mov esi, ptframe
mov edi, Log
mov edx, edi
xor eax, eax
NewLine:
lodsb ; Nb Block
or al, al
je EndLine
mov bl, al
SameLine:
lodsb
test al, al
js short CopyPix ;
mov ecx, eax
;----------------------
lodsb
rep stosb
;----------------------
dec bl
jne short SameLine
jmp short EndLine
CopyPix:
;----------------------
neg al
mov ecx, eax
shr ecx, 2
rep movsd
mov cl, al
and cl, 11b
rep movsb
;----------------------
dec bl
jne short SameLine
EndLine:
add edx, [deltax]
mov edi, edx
dec dword ptr [deltay]
jne short NewLine
EndDrawFrame:
ret
DrawFrame endp
;----------------------------------------------------------------------------
UpdateFrame proc uses esi edi ebx,\
ptframe:DWORD, deltax:DWORD
local cptline :WORD
mov esi, ptframe
mov edi, Log
xor eax, eax
lodsw
mov edx, deltax
imul edx
add edi, eax
mov edx, edi
lodsw
mov [cptline], ax
xor eax, eax
NewLine:
lodsb ; Nb Block
or al, al
je EndLine
mov bl, al
SameLine:
lodsb
add edi, eax
lodsb
test al, al
js short RepeatPix ;
mov ecx, eax
shr ecx, 2
rep movsd
mov cl, al
and cl, 11b
rep movsb
dec bl
jne short SameLine
jmp short EndLine
RepeatPix:
neg al
mov ecx, eax
lodsb
rep stosb
dec bl
jne short SameLine
EndLine:
add edx, deltax
mov edi, edx
dec word ptr [cptline]
jne short NewLine
EndUpdateFrame:
ret
UpdateFrame endp
;----------------------------------------------------------------------------
BlackFrame proc uses edi
mov edi, Log
xor eax, eax
mov edx, 200
NextLine:
mov ecx, 320/4
rep stosd
add edi, 320
dec edx
jne NextLine
ret
BlackFrame endp
;----------------------------------------------------------------------------
CopyFrame proc uses esi edi,\
ptsrc:DWORD
mov esi, ptsrc
mov edi, Log
mov edx, 200
NextLine:
mov ecx, 320/4
rep movsd
add edi, 320
dec edx
jne NextLine
ret
CopyFrame endp
;----------------------------------------------------------------------------
comment #
SetPal proc uses esi edi ebx,\
ptsrc:DWORD
mov esi, ptsrc
xor edi, edi
lodsw
mov bx, ax
test bx, bx
je EndSetPal
Again:
xor eax, eax
lodsb
add di, ax
lodsb
mov ecx, eax
or ecx, ecx
jne PlusLoin
mov ecx, 256
PlusLoin:
mov dx, 3C8h
mov ax, di
out dx, al
inc di
inc dx
lodsb
out dx, al
lodsb
out dx, al
lodsb
out dx, al
loop PlusLoin
dec bx
jne Again
EndSetPal:
ret
SetPal endp
;----------------------------------------------------------------------------
CpyPal proc uses esi edi ebx,\
ptsrc:DWORD, ptdst:DWORD
mov esi, ptsrc
mov edi, ptdst
lodsw
mov bx, ax
test bx, bx
je EndCpyPal
Again:
xor eax, eax
lodsb
add di, ax
add di, ax
add di, ax
lodsb
or al, al
jne PlusLoin
mov eax, 256
PlusLoin:
mov ecx, eax
add ecx, eax
add ecx, eax
mfp0: lodsb
shl al, 2
stosb
loop mfp0
; rep movsb
dec bx
jne Again
EndCpyPal:
ret
CpyPal endp
#
;----------------------------------------------------------------------------
; The
End

504
SOURCES/AMBIANCE.C Normal file
View File

@@ -0,0 +1,504 @@
#include "c_extern.h"
#include "Balance.h"
#ifdef CDROM
extern LONG FlagVoiceCD ;
LONG CurrentMusicCD = -1 ;
ULONG EndMusicCD = 0 ;
#endif
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
ÛßßßÛ ÛÜ ÜÛ ÛßßÛ Û ÛßßßÛ ÛÛÜ Û Ûßßßß Ûßßßß
ÛÛßßÛ ÛÛß Û ÛÛßßÛ ÛÛ ÛÛßßÛ ÛÛßÛÛ ÛÛ ÛÛßß
ßß ß ßß ß ßßßßß ßß ßß ß ßß ß ßßßßß ßßßßß
*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
ULONG HQ_MixSample( WORD numsample, WORD decalage, WORD repeat, WORD volleft, WORD volright )
{
UBYTE string[256] ;
ULONG retvalue ;
UBYTE *ptr ;
retvalue = -1 ;
if( !SamplesEnable ) return -1 ;
if ( numsample == -1 ) return -1 ;/* Loran ( Come from GereSceneMenu)*/
ptr = HQR_GetSample( HQR_Samples, numsample ) ;
if( ptr )
{
retvalue =
WavePlay( numsample, decalage, repeat, 0, volleft, volright, ptr ) ;
}
return retvalue ;
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void HQ_StopSample()
{
WaveStop() ;
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void HQ_StopOneSample(WORD num)
{
WaveStopOne( num ) ;
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
WORD GiveBalance( WORD xp, WORD yp, LONG volume, ULONG *volleft, ULONG *volright )
{
LONG balance ;
int flag = 0 ;
if( (yp > 240+480)
OR (yp < -240) ) return FALSE ;
// baisse volume vers le haut … partir de Y<0 jusqu'a -480
if( yp < 0 )
{
volume = RegleTrois32( 0, volume, 240, 240+yp ) ;
flag = 1 ;
}
// baisse volume vers le bas … partir de Y>479 jusqu'a 480+480
if( yp > 479 )
{
volume = RegleTrois32( 0, volume, 240, 240+480-yp ) ;
flag = 1 ;
}
// gere attenuation du volume sur le cote gauche
// utilise le volume eventuellement deja ajuste sur Y
if( (xp >= -320) AND (xp < 0) )
{
*volleft = RegleTrois32( 0, (volume*100)/128, 320, xp+320 ) ;
// *volleft = RegleTrois32( 0, volume, 320, xp+320 ) ;
*volright = 0 ;
return TRUE ;
}
// gere attenuation du volume sur le cote droit
if( (xp >= 640) AND (xp < 640+320) )
{
*volleft = 0 ;
*volright = RegleTrois32( 0, (volume*100)/128, 320, 320+640-xp ) ;
// *volright = RegleTrois32( 0, volume, 320, 320+640-xp ) ;
return TRUE ;
}
// sinon gere la balance gauche/droite sur l'ecran
// l'eventuelle attenuation du volume sur Y est toujour la
if( (xp >= 0) AND (xp < 640) )
{
if (flag) volume = (volume*100)/128;
balance = RegleTrois32( 0,256, 640, xp ) ;
Balance( balance, volume,
volleft, volright ) ;
return TRUE ;
}
return FALSE ;
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
void HQ_3D_MixSample( WORD numsample, WORD decalage, WORD repeat,
WORD x, WORD y, WORD z )
{
ULONG volleft, volright, longhandle ;
LONG balance ;
if( !SamplesEnable ) return ;
ProjettePoint( x-WorldXCube,
y-WorldYCube,
z-WorldZCube ) ;
if( GiveBalance( Xp, Yp, 128, &volleft, &volright ) )
{
longhandle = HQ_MixSample( numsample, decalage, repeat,
volleft, volright ) ;
WaveGiveInfo0( longhandle, (LONG)Xp<<16 + Yp ) ;
}
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void HQ_ChangeBalanceSamples( WORD oldxporg, WORD oldyporg )
{
LONG n, nbsamp ;
T_WAVE *ptrlist ;
LONG deltaxp, newxp ;
LONG deltayp, newyp ;
ULONG volleft, volright ;
return ;
#ifdef TANTPIS
if( !SamplesEnable ) return ;
nbsamp = WaveGetSnap( &ptrlist ) ;
deltaxp = XpOrgw - oldxporg ;
deltaxp = YpOrgw - oldyporg ;
for( n=0; n<nbsamp; n++ )
{
if( ptrlist->LongHandle != 123456 ) // son ambiance
{
newxp = ptrlist->Info0>>16 - deltaxp ;
newyp = ptrlist->Info0&0xFFFF - deltayp ;
if( GiveBalance( newxp, newyp, 128, &volleft, &volright ) )
{
WaveChangeVolume( ptrlist->LongHandle, volleft, volright ) ;
WaveGiveInfo0( ptrlist->LongHandle, newxp<<16 + newyp ) ;
}
else
{
// coupe ce sample longhandle plus tard
WaveStopOne( ptrlist->LongHandle & 0xFFFF ) ;
}
}
ptrlist++ ;
}
#endif
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void GereAmbiance()
{
LONG sample ;
LONG numsample ;
LONG n ;
LONG decal ;
LONG repeat ;
ULONG longhandle ;
if( !SamplesEnable ) return ;
if( TimerRef >= TimerNextAmbiance )
{
sample = Rnd( 4 ) ; /* 0 1 2 3 */
for( n=0; n<4; n++ )
{
if( !(SamplePlayed & (1<<sample)) ) /* si pas joue */
{
SamplePlayed |= (1<<sample) ; /* marque le jou‚ */
if( SamplePlayed == 15 ) /* tous joue */
SamplePlayed = 0 ;
numsample = SampleAmbiance[sample] ;
if( numsample != -1 ) /* si defini */
{
decal = SampleRnd[sample] ;
repeat = SampleRepeat[sample] ;
/* if( repeat == 0 ) // infini
{
if( WaveInList( numsample ) )
{
}
}
*/
longhandle =HQ_MixSample( numsample,
0x1000+Rnd(decal)-(decal/2),
repeat, 110, 110 ) ;
// info son ambiance
// WaveGiveInfo0( longhandle, 123456 ) ;
break ;
}
}
sample++ ;
sample &= 3 ;
}
TimerNextAmbiance = TimerRef
+
( Rnd( SecondEcart ) + SecondMin ) * 50 ;
}
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
ÛßßßÛ ÛßßßÛ Û Ûßßßß ßßÛßß ßßÛßß Ûßßßß
ÛÛßßß ÛÛßßÛ ÛÛ ÛÛßß ÛÛ ÛÛ ÛÛßß
ßß ßß ß ßßßßß ßßßßß ßß ßß ßßßßß
*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
void FadePal( UBYTE r, UBYTE v, UBYTE b, UBYTE *ptrpal, WORD percent )
{
UBYTE workpal[768] ;
LONG n ;
for( n=0; n<256; n++ )
{
workpal[n*3+0] = RegleTrois32( r, ptrpal[n*3+0], 100, percent ) ;
workpal[n*3+1] = RegleTrois32( v, ptrpal[n*3+1], 100, percent ) ;
workpal[n*3+2] = RegleTrois32( b, ptrpal[n*3+2], 100, percent ) ;
}
Palette( workpal ) ;
}
void FadeToBlack( UBYTE *ptrpal )
{
LONG n ;
if( !FlagBlackPal )
{
for( n=100; n>=0; n-=2 )
{
Vsync() ;
FadePal( 0,0,0, ptrpal, n ) ;
}
}
FlagBlackPal = TRUE ;
}
void WhiteFade()
{
UBYTE workpal[768] ;
LONG n,m ;
for( n=0; n<=255; n++ )
{
memset( workpal, n, 768 ) ;
Vsync() ;
Palette( workpal ) ;
}
}
void FadeWhiteToPal( UBYTE *ptrpal )
{
LONG n ;
for( n=0; n<=100; n+=1 )
{
Vsync() ;
FadePal( 255,255,255, ptrpal, n ) ;
}
}
void FadeToPal( UBYTE *ptrpal )
{
LONG n ;
for( n=0; n<=100; n+=2 )
{
Vsync() ;
FadePal( 0,0,0, ptrpal, n ) ;
}
FlagBlackPal = FALSE ;
}
void SetBlackPal()
{
LONG n ;
for( n=0; n<256; n++ )
{
PalOne( n, 0,0,0 ) ;
}
FlagBlackPal = TRUE ;
}
void FadePalToPal( UBYTE *ptrpal, UBYTE *ptrpal1 )
{
UBYTE workpal[768] ;
LONG n,m ;
for( m=0; m<=100; m++ )
{
for( n=0; n<256; n++ )
{
workpal[n*3+0] = RegleTrois32( ptrpal[n*3+0], ptrpal1[n*3+0], 100, m ) ;
workpal[n*3+1] = RegleTrois32( ptrpal[n*3+1], ptrpal1[n*3+1], 100, m ) ;
workpal[n*3+2] = RegleTrois32( ptrpal[n*3+2], ptrpal1[n*3+2], 100, m ) ;
}
Vsync() ;
Palette( workpal ) ;
}
}
void FadeToRed( UBYTE *ptrpal )
{
LONG n ;
for( n=100; n>=0; n-=2 )
{
Vsync() ;
FadePal( 255,0,0, ptrpal, n ) ;
}
}
void FadeRedToPal( UBYTE *ptrpal )
{
LONG n ;
for( n=0; n<=100; n+=2 )
{
Vsync() ;
FadePal( 255,0,0, ptrpal, n ) ;
}
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
ÛÜ ÜÛ Û ÛßßßÜ Û
ÛÛß Û ÛÛ ÛÛ Û ÛÛ
ßß ß ßß ßßßß ßß
*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
#ifdef CDROM
void StopMusicCD( void )
{
StopCDR() ;
CurrentMusicCD = -1 ;
}
#endif
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
void FadeMusicMidi( ULONG t )
{
FadeMidiDown( t ) ;
NumXmi = -1 ;
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
void StopMusicMidi()
{
StopMidi() ;
NumXmi = -1 ;
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
void PlayMusic( WORD num )
{
if( num == -1 )
{
#ifdef CDROM
StopMusicCD() ;
#endif
StopMusicMidi() ;
return ;
}
#ifdef CDROM
if( FlagVoiceCD // voix sur CD music fm
OR (num < 1)
OR (num > 9) ) // ou jingle que FM
{
PlayMidiFile( num ) ;
}
else // voix sur HD ponheur
{
PlayCdTrack( num ) ; // 1ere track = 2
}
#else
PlayMidiFile( num ) ;
#endif
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
void PlayMidiFile( WORD num )
{
if( !Midi_Driver_Enable ) return ;// hum si on peut
#ifdef CDROM
StopMusicCD() ;
#endif
if( (num != NumXmi)
OR (!IsMidiPlaying()) )
{
StopMusicMidi() ;
// HQR_Reset_Ressource( HQR_Midi ) ;
PtrXmi = HQR_Get( HQR_Midi, num ) ;
NumXmi = num ;
PlayMidi( PtrXmi ) ;
VolumeMidi( 100 ) ;
}
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
#ifdef CDROM
LONG GetMusicCD()
{
if ( TimerSystem > EndMusicCD) CurrentMusicCD = -1 ;
return CurrentMusicCD ;
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
void PlayCdTrack( WORD num )
{
LONG t ;
SaveTimer() ;
FadeMusicMidi( 1 ) ;
NumXmi = -1 ;
if (num != GetMusicCD())
{
StopMusicCD() ;
EndMusicCD = ( GetLengthTrackCDR( num+1 ) * 50 ) / 75 + 50 ;
PlayTrackCDR( num + 1 ) ;
EndMusicCD += TimerSystem ;
CurrentMusicCD = num ;
}
RestoreTimer() ;
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
void PlayAllMusic( WORD num )
{
if( Midi_Driver_Enable )
{
if( (num != NumXmi)
OR (!IsMidiPlaying()) )
{
StopMusicMidi() ;
PtrXmi = HQR_Get( HQR_Midi, num ) ;
NumXmi = num ;
PlayMidi( PtrXmi ) ;
VolumeMidi( 100 ) ;
}
}
// if( (n=num+1) != GetMusicCDR() )
if( num != GetMusicCD() )
{
StopMusicCD() ;
EndMusicCD = ( GetLengthTrackCDR( num+1 ) * 50 ) / 75 + 50 ;
PlayTrackCDR( num+1 ) ;
EndMusicCD += TimerSystem ;
CurrentMusicCD = num ;
}
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
#endif

20
SOURCES/AMBIANCE.DEF Normal file
View File

@@ -0,0 +1,20 @@
extern unsigned long HQ_MixSample(short ,short ,short ,short ,short );
extern void HQ_StopSample(void);
extern void HQ_StopOneSample(short );
extern short GiveBalance(short ,short ,long ,unsigned long *,unsigned long *);
extern void HQ_3D_MixSample(short ,short ,short ,short ,short ,short );
extern void HQ_ChangeBalanceSamples(short ,short );
extern void GereAmbiance(void);
extern void FadePal(unsigned char ,unsigned char ,unsigned char ,unsigned char *,short );
extern void FadeToBlack(unsigned char *);
extern void WhiteFade(void);
extern void FadeWhiteToPal(unsigned char *);
extern void FadeToPal(unsigned char *);
extern void SetBlackPal(void);
extern void FadePalToPal(unsigned char *,unsigned char *);
extern void FadeToRed(unsigned char *);
extern void FadeRedToPal(unsigned char *);
extern void FadeMusicMidi(unsigned long );
extern void StopMusicMidi(void);
extern void PlayMusic(short );
extern void PlayMidiFile(short );

72
SOURCES/BALANCE.ASM Normal file
View File

@@ -0,0 +1,72 @@
.386p
jumps
.model SMALL, SYSCALL
.data
extrn NoLanguage P_SinTab:WORD
.code
public NoLanguage Balance
public NoLanguage BalanceWord
Balance PROC uses ebx,\
bal:DWORD, vol:DWORD, volleft:DWORD, volright:DWORD
mov eax, bal
shl eax, 1
mov edx, vol
xor ecx, ecx
mov cx, word ptr[P_SinTab + eax]
imul ecx, edx
shr ecx, 14
mov ebx, volright
mov dword ptr[ebx], ecx
xor ecx, ecx
mov cx, word ptr[P_SinTab + 512 + eax]
imul ecx, edx
shr ecx, 14
mov ebx, volleft
mov dword ptr[ebx], ecx
ret
Balance ENDP
BalanceWord PROC uses ebx,\
bal:DWORD, vol:DWORD, volleft:DWORD, volright:DWORD
mov eax, bal
shl eax, 1
mov edx, vol
xor ecx, ecx
mov cx, word ptr[P_SinTab + eax]
imul ecx, edx
shr ecx, 14
mov ebx, volright
mov word ptr[ebx], cx
xor ecx, ecx
mov cx, word ptr[P_SinTab + 512 + eax]
imul ecx, edx
shr ecx, 14
mov ebx, volleft
mov word ptr[ebx], cx
ret
BalanceWord ENDP
END

4
SOURCES/BALANCE.H Normal file
View File

@@ -0,0 +1,4 @@
/* balance between 0 and 256, volume between 0 and 128 */
void Balance( ULONG balance, ULONG volume, ULONG *vol_left, ULONG *vol_right ) ;
void BalanceWord( ULONG balance, ULONG volume, UWORD *vol_left, UWORD *vol_right ) ;

29
SOURCES/BUBSORT.C Normal file
View File

@@ -0,0 +1,29 @@
void BubbleSort( UBYTE *base,
size_t nelem,
size_t width,
int (*fcmp)(const void *, const void *))
{
int i, j;
register UBYTE *o1, *o2, *s;
UBYTE *temp=&base[width*nelem];
o1 = base ;
for(i=1; i<nelem; i++)
{
o2 = o1+width ;
s = o1 ;
for(j=i; j<nelem; j++)
{
if ((*fcmp)(s, o2)>0)
s = o2 ;
o2 += width;
}
if (s!=o1)
{
memcpy(temp, o1, width);
memcpy(o1, s, width);
memcpy(s, temp, width);
}
o1 += width;
}
}

561
SOURCES/COMMON.H Normal file
View File

@@ -0,0 +1,561 @@
/*---------------- RESSOURCE (RESS_HQR) ------------------*/
#define RESS_PAL 0
#define RESS_FONT_GPM 1
#define RESS_EMPTY 2
#define RESS_GOODIES_GPC 3
#define RESS_SHADOW_GPH 4
#define RESS_HOLOMAP_PAL 5
#define RESS_HOLOMAP_HMT 6
#define RESS_HOLOMAP_HMG 7
#define RESS_HOLOMAP_POS 8
#define RESS_HOLO_TWINKEL 9
#define RESS_HOLO_FLECHE 10
#define RESS_HOLO_BODYFLECHE 11
#define RESS_BUMPER_PCR 12
#define RESS_BUMPER_PAL 13
#define RESS_MENU_PCR 14
#define RESS_TWINSUN_PCR 15
#define RESS_TWINSUN_PAL 16
#define RESS_INTRO_2_PCR 17
#define RESS_INTRO_2_PAL 18
#define RESS_INTRO_3_PCR 19
#define RESS_INTRO_3_PAL 20
#define RESS_GAME_OVER 21
#define RESS_PAL_ALARM 22
#define RESS_FLA_PCX 23
#define RESS_PAL_MUSEE 24
#define RESS_SENDELL_PCR 25
#define RESS_SENDELL_PAL 26
#define RESS_LOGO_PCR 27
#define RESS_LOGO_PAL 28
#define RESS_HOLO_CONE 29
#define RESS_HOLOMAP_TRAJ 30
#define RESS_HOLO_VEHICULE 31
// vehicule de 31 … 48
#define RESS_BUMPER2_PCR 49
#define RESS_BUMPER2_PAL 50
#define RESS_INIT_PLASMA 51
#define RESS_BUMPER_EA_PCR 52
#define RESS_BUMPER_EA_PAL 53
/*----------------- CUBE ----------------------*/
#define SIZE_CUBE_X 64
#define SIZE_CUBE_Y 25
#define SIZE_CUBE_Z 64
#define SIZE_BRICK_XZ 512
#define SIZE_BRICK_Y 256
#define DEMI_BRICK_XZ 256
#define DEMI_BRICK_Y 128
#define VIEW_X0 -50
#define VIEW_Y0 -30
#define VIEW_X1 680
#define VIEW_Y1 580
/*---------------- FLAG_GAME ------------------*/
#define FLAG_HOLOMAP 0
#define FLAG_BALLE_MAGIQUE 1
#define FLAG_SABRE_MAGIQUE 2
#define FLAG_TROMPE 3
#define FLAG_TUNIQUE 4
#define FLAG_LIVRE_BU 5
#define FLAG_MEDAILLON 6
#define FLAG_FLACON_EAU_CLAIRE 7
#define FLAG_MECA_PINGOUIN 14
#define FLAG_CARBURANT 15
#define FLAG_CLOVER 27
#define FLAG_CONSIGNE 70
/*---------------- SAMPLES ------------------*/
#define MAX_SAMPLES 300
/*---------------- OBJECTS ------------------*/
#define MAX_OBJETS 100
#define MAX_EXTRAS 50
#define SIZE_NAME 19
#define MAX_ANIMS 400
#define MAX_BODYS 200
#define MAX_FLAGS 255
#define MAX_ZONES 255
/*#define MAX_CODES 255 */
#define MAX_TRACKS 255
#define MAX_FLAGS_CUBE 80
#define MAX_FLAGS_GAME 255
#define MAX_INVENTORY 28
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
#define MAX_CLOVER_BOX 10
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
/* type objet pour affscene */
#define TYPE_OBJ_3D (1024*0)
#define TYPE_FLAG_RED (1024*1)
#define TYPE_FLAG_YELLOW (1024*2)
#define TYPE_SHADOW (1024*3)
#define TYPE_OBJ_SPRITE (1024*4)
#define TYPE_ZONE_DEC (1024*5)
#define TYPE_EXTRA (1024*6)
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
/* work flags */
#define WAIT_HIT_FRAME 1
#define OK_HIT 2
#define ANIM_END 4
#define NEW_FRAME 8
#define WAS_DRAWN 16
#define OBJ_DEAD 32
#define AUTO_STOP_DOOR 64
#define ANIM_MASTER_ROT 128
#define FALLING 256
/* Flags */
#define CHECK_OBJ_COL 1 // test des collisions et hit obj
#define CHECK_BRICK_COL 2 // test des collisions decors
#define CHECK_ZONE 4 // test des zones scenariques
#define SPRITE_CLIP 8 // (portes) zone de clip fixe
#define PUSHABLE 16 // poussable
#define COL_BASSE 32 // 1 = pas test des collisions hautes TWINSEN
#define CHECK_CODE_JEU 64 // test la noyade
#define INVISIBLE 512 // not drawn but all computed
#define SPRITE_3D 1024 // un sprite pas un 3DO
#define OBJ_FALLABLE 2048 // peut tomber
#define NO_SHADOW 4096 // pas d'ombre auto
#define OBJ_BACKGROUND 8192 // s'incruste dans le decor la 1er fois
#define OBJ_CARRIER 16384 // peut porter et deplacer un obj
#define MINI_ZV 32768 // zv carre sur plus petit cote (si 3DO)
/* Option Flags */
#define EXTRA_MASK (16+32+64+128+256)
#define EXTRA_GIVE_NOTHING 1
#define EXTRA_GIVE_MONEY 16
#define EXTRA_GIVE_LIFE 32
#define EXTRA_GIVE_MAGIC 64
#define EXTRA_GIVE_KEY 128
#define EXTRA_GIVE_CLOVER 256
/* FlagAnim */
#define ANIM_REPEAT 0
#define ANIM_THEN 1
#define ANIM_ALL_THEN 2
#define ANIM_INSERT 3
#define ANIM_SET 4
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
#define EXTRA_TIME_OUT 1
#define EXTRA_FLY 2
#define EXTRA_END_OBJ 4
#define EXTRA_END_COL 8
#define EXTRA_STOP_COL 16
#define EXTRA_TAKABLE 32
#define EXTRA_FLASH 64
#define EXTRA_SEARCH_OBJ 128
#define EXTRA_IMPACT 256
#define EXTRA_SEARCH_KEY 512
#define EXTRA_TIME_IN 1024
#define EXTRA_ONE_FRAME 2048
#define EXTRA_EXPLO 4096
#define EXTRA_WAIT_NO_COL 8192
#define EXTRA_WAIT_SOME_TIME 16384
typedef struct
{
WORD Sprite ; /* num sprite */
WORD PosX ;
WORD PosY ;
WORD PosZ ;
WORD OrgX ;
WORD OrgY ;
WORD OrgZ ;
WORD Vx ;
WORD Vy ;
WORD Vz ;
WORD Flags ;
WORD Poids ;
ULONG Timer ; /* memo timer 50hz */
WORD TimeOut ; /* life time */
WORD HitForce ; /* si !=0 force de frappe */
WORD Divers ; /* nombre pour zone giver */
} T_EXTRA ;
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
typedef struct
{
WORD X0 ;
WORD Y0 ;
WORD Z0 ;
WORD X1 ;
WORD Y1 ;
WORD Z1 ;
WORD Type ;
WORD Num ;
WORD Info0 ;
WORD Info1 ;
WORD Info2 ;
WORD Info3 ; } T_ZONE ;
typedef struct
{
WORD Z ;
WORD NumObj ;
WORD Xw ;
WORD Yw ;
WORD Zw ;
WORD Num ;
/* WORD Xmin ;
WORD Ymin ;
WORD Zmin ;
WORD Xmax ;
WORD Ymax ;
WORD Zmax ; */
} T_SORT ;
/*---------------- holomap -----------------*/
/*
#define MAX_HOLO_OBJ 50
typedef struct { WORD Alpha ;
WORD Beta ;
WORD Size ;
WORD Obj ;
WORD Flag ;
WORD Info ; } T_HOLO_OBJ ;
*/
#define MAX_HOLO_POS 150
typedef struct { WORD Alpha ;
WORD Beta ;
WORD Size ;
// WORD XIsland ;
// WORD ZIsland ;
// UBYTE Type ;
WORD Mess ;
// WORD Fleche ;
} T_HOLO_POS ;
/*---------------- incrust display ---------*/
#define MAX_INCRUST_DISP 10
#define INCRUST_SPRITE 0
#define INCRUST_NUM 1
#define INCRUST_CMPT 2
#define INCRUST_OBJ 3
#define INCRUST_TEXT 4
typedef struct { WORD Num ;
WORD X ;
WORD Y ;
WORD Type ;
WORD Info ;
WORD Move ;
ULONG TimerEnd ; } T_INCRUST_DISP ;
/*---------------- divers ------------------*/
#define START_FILE_ISLAND 3
#define Rnd(n) (rand()%n)
#define NUM_PERSO 0
#define C_NORMAL 0
#define C_SPORTIF 1
#define C_AGRESSIF 2
#define C_DISCRET 3
#define C_PROTOPACK 4
#define ACTIVE_LIFE 0
#define ACTIVE_TRACK 1
#define MAX_TYPES_ZONE 7
#define POS_MIDDLE 1
#define POS_LEFT 2
#define POS_RIGHT 4
#define POS_UP 8
#define POS_DOWN 16
/*---------------- Script: defines ------------------*/
#define NO_MOVE 0
#define MOVE_MANUAL 1
#define MOVE_FOLLOW 2
#define MOVE_TRACK 3
#define MOVE_FOLLOW_2 4
#define MOVE_TRACK_ATTACK 5
#define MOVE_SAME_XZ 6
#define MOVE_RANDOM 7
#define NB_MOVES 8
/*---------------- Track: macros ------------------*/
#define TM_END 0
#define TM_NOP 1
#define TM_BODY 2
#define TM_ANIM 3
#define TM_GOTO_POINT 4
#define TM_WAIT_ANIM 5
#define TM_LOOP 6
#define TM_ANGLE 7
#define TM_POS_POINT 8
#define TM_LABEL 9
#define TM_GOTO 10
#define TM_STOP 11
#define TM_GOTO_SYM_POINT 12
#define TM_WAIT_NB_ANIM 13
#define TM_SAMPLE 14
#define TM_GOTO_POINT_3D 15
#define TM_SPEED 16
#define TM_BACKGROUND 17
#define TM_WAIT_NB_SECOND 18
#define TM_NO_BODY 19
#define TM_BETA 20
#define TM_OPEN_LEFT 21
#define TM_OPEN_RIGHT 22
#define TM_OPEN_UP 23
#define TM_OPEN_DOWN 24
#define TM_CLOSE 25
#define TM_WAIT_DOOR 26
#define TM_SAMPLE_RND 27
#define TM_SAMPLE_ALWAYS 28
#define TM_SAMPLE_STOP 29
#define TM_PLAY_FLA 30
#define TM_REPEAT_SAMPLE 31
#define TM_SIMPLE_SAMPLE 32
#define TM_FACE_TWINKEL 33
#define TM_ANGLE_RND 34
#define NB_MACROS_TRACK 35
/*---------------- Life: macro ------------------*/
/*---*/
#define LM_END 0
#define LM_NOP 1
#define LM_SNIF 2
#define LM_OFFSET 3
#define LM_NEVERIF 4
#define LM_LABEL 10
#define LM_RETURN 11
#define LM_IF 12
#define LM_SWIF 13
#define LM_ONEIF 14
#define LM_ELSE 15
#define LM_ENDIF 16
#define LM_BODY 17
#define LM_BODY_OBJ 18
#define LM_ANIM 19
#define LM_ANIM_OBJ 20
#define LM_SET_LIFE 21
#define LM_SET_LIFE_OBJ 22
#define LM_SET_TRACK 23
#define LM_SET_TRACK_OBJ 24
#define LM_MESSAGE 25
#define LM_FALLABLE 26
#define LM_SET_DIR 27
#define LM_SET_DIR_OBJ 28
#define LM_CAM_FOLLOW 29
#define LM_COMPORTEMENT_HERO 30
#define LM_SET_FLAG_CUBE 31
#define LM_COMPORTEMENT 32
#define LM_SET_COMPORTEMENT 33
#define LM_SET_COMPORTEMENT_OBJ 34
#define LM_END_COMPORTEMENT 35
#define LM_SET_FLAG_GAME 36
#define LM_KILL_OBJ 37
#define LM_SUICIDE 38
#define LM_USE_ONE_LITTLE_KEY 39
#define LM_GIVE_GOLD_PIECES 40
#define LM_END_LIFE 41
#define LM_STOP_L_TRACK 42
#define LM_RESTORE_L_TRACK 43
#define LM_MESSAGE_OBJ 44
#define LM_INC_CHAPTER 45
#define LM_FOUND_OBJECT 46
#define LM_SET_DOOR_LEFT 47
#define LM_SET_DOOR_RIGHT 48
#define LM_SET_DOOR_UP 49
#define LM_SET_DOOR_DOWN 50
#define LM_GIVE_BONUS 51
#define LM_CHANGE_CUBE 52
#define LM_OBJ_COL 53
#define LM_BRICK_COL 54
#define LM_OR_IF 55
#define LM_INVISIBLE 56
#define LM_ZOOM 57
#define LM_POS_POINT 58
#define LM_SET_MAGIC_LEVEL 59
#define LM_SUB_MAGIC_POINT 60
#define LM_SET_LIFE_POINT_OBJ 61
#define LM_SUB_LIFE_POINT_OBJ 62
#define LM_HIT_OBJ 63
#define LM_PLAY_FLA 64
#define LM_PLAY_MIDI 65
#define LM_INC_CLOVER_BOX 66
#define LM_SET_USED_INVENTORY 67
#define LM_ADD_CHOICE 68
#define LM_ASK_CHOICE 69
#define LM_BIG_MESSAGE 70
#define LM_INIT_PINGOUIN 71
#define LM_SET_HOLO_POS 72
#define LM_CLR_HOLO_POS 73
#define LM_ADD_FUEL 74
#define LM_SUB_FUEL 75
#define LM_SET_GRM 76
#define LM_SAY_MESSAGE 77
#define LM_SAY_MESSAGE_OBJ 78
#define LM_FULL_POINT 79
#define LM_BETA 80
#define LM_GRM_OFF 81
#define LM_FADE_PAL_RED 82
#define LM_FADE_ALARM_RED 83
#define LM_FADE_ALARM_PAL 84
#define LM_FADE_RED_PAL 85
#define LM_FADE_RED_ALARM 86
#define LM_FADE_PAL_ALARM 87
#define LM_EXPLODE_OBJ 88
#define LM_BULLE_ON 89
#define LM_BULLE_OFF 90
#define LM_ASK_CHOICE_OBJ 91
#define LM_SET_DARK_PAL 92
#define LM_SET_NORMAL_PAL 93
#define LM_MESSAGE_SENDELL 94
#define LM_ANIM_SET 95
#define LM_HOLOMAP_TRAJ 96
#define LM_GAME_OVER 97
#define LM_THE_END 98
#define LM_MIDI_OFF 99
#define LM_PLAY_CD_TRACK 100
#define LM_PROJ_ISO 101
#define LM_PROJ_3D 102
#define LM_TEXT 103
#define LM_CLEAR_TEXT 104
#define LM_BRUTAL_EXIT 105
#define NB_MACROS_LIFE 106
/*---*/
#define LF_COL 0
#define LF_COL_OBJ 1
#define LF_DISTANCE 2
#define LF_ZONE 3
#define LF_ZONE_OBJ 4
#define LF_BODY 5
#define LF_BODY_OBJ 6
#define LF_ANIM 7
#define LF_ANIM_OBJ 8
#define LF_L_TRACK 9
#define LF_L_TRACK_OBJ 10
#define LF_FLAG_CUBE 11
#define LF_CONE_VIEW 12
#define LF_HIT_BY 13
#define LF_ACTION 14
#define LF_FLAG_GAME 15
#define LF_LIFE_POINT 16
#define LF_LIFE_POINT_OBJ 17
#define LF_NB_LITTLE_KEYS 18
#define LF_NB_GOLD_PIECES 19
#define LF_COMPORTEMENT_HERO 20
#define LF_CHAPTER 21
#define LF_DISTANCE_3D 22
#define LF_MAGIC_LEVEL 23
#define LF_MAGIC_POINT 24
#define LF_USE_INVENTORY 25
#define LF_CHOICE 26
#define LF_FUEL 27
#define LF_CARRY_BY 28
#define LF_CDROM 29
#define NB_FUNCS_LIFE 30
/*---*/
#define LT_EQUAL 0
#define LT_SUP 1
#define LT_LESS 2
#define LT_SUP_EQUAL 3
#define LT_LESS_EQUAL 4
#define LT_DIFFERENT 5
#define NB_TESTS_LIFE 6
/*---------------- The End: error ------------------*/
#define ERROR_FILE_NOT_FOUND 0
#define NOT_ENOUGH_MEM 1
#define PROGRAM_OK 2
#define NAME_NOT_FOUND 3

376
SOURCES/CPYMASK.ASM Normal file
View File

@@ -0,0 +1,376 @@
;----------------------------------------------------------------------------
; Mask_A.ASM 386
; (c) Adeline 1993
;----------------------------------------------------------------------------
.386P
jumps
.model SMALL, SYSCALL
;----------------------------------------------------------------------------
.data
;----------------------------------------------------------------------------
include \projet\lib386\lib_svga\svga.ash
comment @
DWORD TabOffset[]
Brick:
- BYTE Delta X
- BYTE Delta Y
Line(Delta Y):
- BYTE NbBlock
Block 0: Nb Zero to Jump
Block 1: Nb Zero to Write
Block 2: Nb Zero to Jump
etc...
@
BufferClip db 512 dup(?)
OffsetBegin dd 0
NbPix dd 0
save_esi dd ?
extrn NoLanguage Screen:DWORD
;----------------------------------------------------------------------------
.code
public NoLanguage CopyMask
;----------------------------------------------------------------------------
CopyMask proc uses esi edi ebx ebp,\
nummask:DWORD, xmask:DWORD, ymask:DWORD, \
bankmask:DWORD, ptsrc:DWORD
mov esi, ptsrc
mov eax, nummask
mov ebx, xmask
mov ecx, ymask
mov ebp, bankmask
add ebp, [ebp+eax*4] ; EBP = Begin Data
xor eax, eax
mov al, [ebp+2] ; Hot X
add ebx, eax
mov al, [ebp+3] ; Hot Y
add ecx, eax
;-----------------------------------------------
xor edx, edx
mov dl, [ebp] ; Delta X
mov al, [ebp+1] ; Nb Line ( Delta Y )
add ebp, 4 ; Jump Hot X & Hot Y
;----------------------------------------------- Test Clipping
add edx, ebx
add eax, ecx
dec edx
dec eax
cmp ebx, ClipXmin
jl ClippingMask
cmp ecx, ClipYmin
jl ClippingMask
cmp edx, ClipXmax
jg ClippingMask
cmp eax, ClipYmax
jg ClippingMask
inc edx
inc eax
sub edx, ebx
sub eax, ecx
;----------------------------------------------- Calcul Offset Ecran
add ebx, TabOffLine[ecx*4]
mov edi, Log
add esi, ebx
add edi, ebx
mov bh, al ; BH = NbLine
sub edx, Screen_X ; EDX = Offset Screen
neg edx ; EDX = Screen_X-edx
xor ecx, ecx ; Maz Compteur
;----------------------------------------------- Init NbBlock for this line
NextLine: mov bl, [ebp] ; BL = Nb Block for this line
inc ebp
;----------------------------------------------- Manage One Line
SameLine: mov cl, [ebp] ; Nb Zero to Jump
add edi, ecx ; Incrust on Log
add esi, ecx ; And on PtSrc
dec bl
je EndBlock
mov cl, [ebp+1] ; Nb Zero to Write
add ebp, 2
mov al, cl
shr cl, 2
and al, 11b
rep movsd ; Write Datas From PtSrc
mov cl, al
rep movsb
dec bl ; Nb Block--
jne SameLine ; Continue Same Line
add edi, edx ; EDI += Offset Screen
add esi, edx
dec bh ; NbLine--
jne NextLine ; Next Line
ret
EndBlock:
inc ebp
add edi, edx ; EDI += Offset Screen
add esi, edx
dec bh ; NbLine--
jne NextLine ; Next Line
ret
;-------------------------------------------------------------------- Clipping
; Graph : ( EBX, ECX ) ( EDX, EAX )
ClippingMask:
cmp ebx, ClipXmax
jg EndMask
cmp ecx, ClipYmax
jg EndMask
cmp edx, ClipXmin
jl EndMask
cmp eax, ClipYmin
jl EndMask
cmp ecx, ClipYmin
jge PasHaut
;---------------------- Clipping Haut, Saute ClipYmin-ECX Line(s)
sub ecx, ClipYMin
neg ecx
mov esi, eax
xor eax, eax
NextH: mov al, [ebp]
lea ebp, [ebp+1+eax]
dec ecx
jnz NextH
mov eax, esi
mov ecx, ClipYMin
;---------------------- Clipping Bas
PasHaut: cmp eax, ClipYmax
jle PasBas
mov eax, ClipYmax
;---------------------- Clipping Gauche
Pasbas: mov OffsetBegin, 0
cmp ebx, ClipXmin
jge PasGauche
mov esi, ClipXmin
sub esi, ebx
mov OffsetBegin, esi
;---------------------- Clipping Droit
PasGauche:
mov esi, edx
sub esi, ebx
sub esi, OffsetBegin
inc esi
mov NbPix, esi
cmp edx, ClipXmax
jle PasDroit
sub edx, ClipXmax
sub NbPix, edx
mov edx, ClipXmax
;----------------------
PasDroit: ; ESI debut data Y ok pas X
; EBX not clipped X0
; ECX good Y0
; EAX clipped Y1
; NbPix real X nb pix
; OffsetBegin start X ( !!!!! < 128 )
mov edx, TabOffLine[ecx*4]
add edx, ebx
add edx, [OffsetBegin]
lea ebx, [eax+1]
mov eax, edx ; good Y offset screen
add edx, Log
add eax, Screen ; Screen
sub ebx, ecx
xor ecx, ecx
jmp start
aplus: mov cl, bl
add ebp, ecx
aplus2: shr ebx, 16
dec bl
jz EndMask
l1: inc ebp
add eax, 640
add edx, 640
start:
shl ebx, 16
mov cl, byte ptr[OffsetBegin]; start x
; cl = nb pix count
mov bh, byte ptr[NbPix] ; nb point … copier
mov esi, eax
mov edi, edx ; new pos screen
mov bl, [ebp] ; nb blocs
l0: inc ebp
dec bl
jz aplus2
sub cl, [ebp] ; nb pix to jump
jc rptj ; reste pix to jump
jz okdraw ; tombe pile
inc ebp
dec bl
sub cl, [ebp] ; nb copy point
jc rgtc ; reste graph to copy
jz okjump2
or bl, bl
jnz l0
shr ebx, 16
dec bl ; nb lig--
jnz l1
ret
rptj:
; cl = - nb pix to jump
add bh, cl ; reste … ecrire
jle aplus
neg cl
jmp okdraw2
rgtc:
neg cl ; cl nb pix to copy
sub bh, cl ; reste … ecrire
jc cpt ; copy pas tout
rep movsb ; copy
jz aplus
okjump2: or bl, bl
jz aplus2
okjump: inc ebp
dec bl
jz aplus2
mov cl, [ebp] ; nb pix to jump
sub bh, cl ; reste … ecrire
jle aplus ; fini
okdraw2:
add edi, ecx
add esi, ecx
okdraw: inc ebp
dec bl ; nb bloc--
mov cl, [ebp] ; nb pix to copy
sub bh, cl ; reste … ecrire
jc cpt ; copy pas tout
rep movsb ; copy
jz aplus ; tombe pile
or bl, bl
jnz okjump
shr ebx, 16
dec bl ; nb lig--
jnz l1
ret
cpt: add cl, bh
rep movsb
; ligne finie
mov cl, bl
add ebp, ecx
shr ebx, 16
dec bl ; nb lig--
jnz l1
EndMask: ret
comment #
add ebx, TabOffLine[ecx*4]
mov edi, Log
add edi, ebx
sub eax, ecx
inc al
mov bh, al ; BH NbLine
xor ecx, ecx
mov ebp, edi
;----------------------------------------------
; ESI = DATAS LINE
NextL: lea edi, BufferClip ; EDI = BUFFERCLIP
lodsb ; NbBlock
mov bl, al
SameL: lodsb
mov cl, al
mov al, 1
rep stosb
dec bl
je EndLine
lodsb
mov cl, al
xor al, al
rep stosb
dec bl
jne SameL
;----------------------
EndLine: push esi ; SAVE ESI
lea esi, BufferClip ; ESI = BUFFERCLIP
mov edi, ebp ; EDI = SCREEN
mov ecx, OffsetBegin
add esi, ecx
add edi, ecx
mov ecx, NbPix
;----------------------
Again:
lodsb
or al, al
jne Incrust
mov [edi], al
Incrust: inc edi
loop Again
add ebp, 640
pop esi
dec bh
jne NextL
;----------------------
#
CopyMask endp
;----------------------------------------------------------------------------
; The
End

352
SOURCES/C_EXTERN.H Normal file
View File

@@ -0,0 +1,352 @@
#include "defines.h"
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
#include "ambiance.def"
#include "diskfunc.def"
#include "extra.def"
#include "fiche.def"
#include "flipbox.def"
#include "gamemenu.def"
#include "gerelife.def"
#include "geretrak.def"
#include "grille.def"
#include "holomap.def"
#include "incrust.def"
#include "message.def"
#include "object.def"
#include "perso.def"
#include "playfla.def"
/* prototype */
char *GetMultiText( LONG text, char *dst ) ;
WORD GiveObjSelect( WORD type, LONG xm, LONG ym ) ;
UBYTE WorldColBrick( WORD xw, WORD yw, WORD zw ) ;
WORD ThrowExtra( WORD owner,
WORD x, WORD y, WORD z, WORD num,
WORD alpha, WORD beta, WORD vitesse, WORD poids,
WORD hitforce ) ;
WORD GetValue() ;
WORD GetListObjet( WORD x0, WORD y0 ) ;
LONG SceReadWord() ;
WORD SearchLastZoneSce() ;
ULONG HQ_MixSample( WORD numsample, WORD decalage, WORD repeat, WORD volleft, WORD volright ) ;
void HQ_StopOneSample( WORD num ) ;
void *LoadTestMalloc( char *filename ) ;
WORD InitAnim( UBYTE gen_anim, WORD flag, UBYTE gen_nextanim, WORD numobj ) ;
WORD SearchAnim( UBYTE numanim, WORD numobj ) ;
WORD SearchBody( UBYTE numbody, WORD numobj ) ;
void LoadFic( UBYTE indexfileobjet, WORD numobj ) ;
/*--------- divers ---------------------------------------------*/
extern UWORD *BufOrder ;
extern UBYTE *BufText ;
extern UBYTE *BufSpeak ;
extern UBYTE GamePathname[] ;
extern WORD ComportementDebug;
extern UBYTE *LbaFont ;
extern UBYTE *Screen ;
extern UBYTE PalettePcx[] ;
extern UBYTE *PtrPal ;
extern WORD MyJoy ;
extern WORD MyFire ;
extern WORD MyKey ;
extern WORD LastFire ;
extern LONG FlagVsync ;
extern WORD FlagMCGA ;
extern LONG FlagCredits ;
extern UBYTE String[] ;
extern UBYTE EditString[] ;
extern WORD Value ;
extern LONG SampleVolume, MusicVolume, CDVolume, LineVolume, MasterVolume ;
extern WORD SamplesEnable ;
extern UBYTE *PtrSample[] ;
extern WORD QuickMessage ;
extern LONG FlecheForcee ;
extern WORD FlagPalettePcx ;
extern WORD FlagFade ;
extern WORD FlagMessageShade ;
extern WORD Bulle ;
extern WORD FlagBlackPal ;
extern WORD FlaFromCD ;
extern UBYTE PathFla[] ;
extern LONG Version_US ;
/*-------- RESSOURCES ---------------------------------------------*/
extern T_HQR_HEADER *HQR_Samples ;
extern T_HQR_HEADER *HQR_Midi ;
extern T_HQR_HEADER *InventoryObj ;
/*-------- DISKFUNC.C ---------------------------------------------*/
extern char PleaseWait[] ;
extern UBYTE ProgDrive[] ;
extern UBYTE ProgDir[] ;
extern ULONG OrgDrive ;
extern UBYTE OrgDir[] ;
extern UBYTE Drive[] ;
extern UBYTE Dir[] ;
extern UBYTE Name[] ;
extern UBYTE Ext[] ;
extern UBYTE OrgPathname[] ;
extern UBYTE ProgramPathname[] ;
extern UBYTE Pathname[] ;
extern UBYTE FliPathname[_MAX_PATH] ;
/*-------- SCRIPT.C ---------------------------------------------*/
extern UBYTE FicName[] ;
extern UBYTE *PtrFiche ;
extern UBYTE *PtrCommand ;
extern UBYTE *PtrFicName ;
/*-------- FLIP_BOX.C ---------------------------------------------*/
extern WORD NbPhysBox ;
extern WORD NbOptPhysBox ;
/*-------- LIB_SVGA ---------------------------------------------*/
extern WORD NbPolyPoints ;
/*-------- life tool ---------------------------------------------*/
extern WORD ErrorFlag ;
extern WORD FlagInfos ;
extern WORD Modif ;
extern UBYTE DefPathname[] ;
extern UBYTE ScePathname[] ;
extern UBYTE PcxPathname[] ;
extern WORD FlagFrame ;
extern T_ZONE *ListZone ;
extern WORD NbZones ;
extern WORD IndexZone ;
extern WORD EditNumZone ;
extern WORD EditTypeZone ;
extern WORD VisuTypeZone ;
extern UBYTE *ListTypeZone[] ;
extern T_TRACK *ListBrickTrack ;
extern WORD NbBrickTrack ;
extern WORD IndexBrickTrack ;
extern WORD EditNumTrack ;
extern WORD ActiveEdit ;
/*
extern T_FLAG ListFlagCube[] ;
extern T_FLAG ListFlagGame[] ;
*/
extern UBYTE ListFlagCube[] ;
extern UBYTE ListFlagGame[] ;
extern UBYTE ListFlagInventory[] ;
extern UBYTE *ListMove[] ;
/*--------- holomap ----------------------------*/
//extern T_HOLO_OBJ ListHoloObj[MAX_HOLO_OBJ] ;
//extern WORD NbHoloObj ;
extern T_HOLO_POS *ListHoloPos ; // [MAX_HOLO_POS] ;
extern UBYTE TabHoloPos[] ;
/*--------- menus -----------------------------*/
extern WORD GameChoice ;
extern WORD GameNbChoices ;
extern WORD GameListChoice[] ;
/*--------- perso ----------------------------*/
extern WORD FlagTheEnd ;
extern WORD ActionNormal ;
extern WORD InventoryAction ;
extern WORD Weapon ;
extern WORD Comportement ;
extern WORD AnimRien ;
extern WORD AnimRienNormal, AnimRienSportif, AnimRienAgressif, AnimRienDiscret, AnimRienProtopack ;
extern UBYTE *PtrFile3dNormal ;
extern UBYTE *PtrFile3dSportif ;
extern UBYTE *PtrFile3dAgressif ;
extern UBYTE *PtrFile3dDiscret ;
extern UBYTE *PtrFile3dProtopack ;
extern WORD SceZoom ;
extern WORD Shadow ;
extern WORD ShadowX, ShadowY, ShadowZ ;
extern UBYTE ShadowCol ;
extern WORD NumHolomapTraj ;
extern WORD FlagChgCube, NewCube, NumCube ;
extern WORD NewPosX, NewPosY, NewPosZ ;
extern WORD SceneStartX, SceneStartY, SceneStartZ ;
extern WORD CubeStartX, CubeStartY, CubeStartZ ;
extern WORD GameOverCube ;
extern WORD CombatAuto ;
extern WORD MagicBall ;
extern WORD MagicBallType ;
extern WORD MagicBallCount ;
extern WORD MagicLevel ;
extern WORD MagicPoint ;
extern WORD NbGoldPieces ;
extern WORD NbLittleKeys ;
extern WORD Chapitre ;
extern UBYTE Island ;
extern WORD Fuel ;
extern WORD NumPingouin ;
extern WORD NbFourLeafClover ;
extern WORD NbCloverBox ;
extern WORD FlagClimbing ;
extern WORD StartYFalling ;
extern T_REAL_VALUE RealFalling ;
extern WORD StepFalling ;
extern UBYTE CodeJeu ;
extern WORD FlagWater ;
// perso sauvegarde entr‚e cube
extern WORD SaveCube ;
extern WORD SaveComportement ;
extern char SaveStringBody[SIZE_NAME+1] ;
extern BYTE SaveGenBody ;
extern WORD SaveBeta ;
extern WORD SaveNbGoldPieces ;
extern WORD SaveMagicLevel ;
extern WORD SaveMagicPoint ;
extern WORD SaveLifePoint ;
extern WORD SaveChapitre ;
extern WORD SaveNbCloverBox ;
extern WORD SaveNbFourLeafClover ;
/*--------- Extra objs ----------------------------*/
extern T_EXTRA ListExtra[] ;
//extern UBYTE *PtrSpriteExtra ;
extern T_HQR_HEADER *HQRPtrSpriteExtra ;
extern WORD *PtrZvExtra ;
/*---------------- incrust display ----------------*/
extern T_INCRUST_DISP ListIncrustDisp[] ;
/*-------- Moteur 3D ---------------------------------------------*/
extern UBYTE *BufferShadow ;
extern UBYTE *BufferAnim ;
extern UBYTE *PtrBufferAnim ;
extern LONG NbBodys ;
extern UBYTE *PtrBody[] ;
extern T_HQR_HEADER *HQR_Anims ;
extern LONG NbObjets ;
extern T_OBJET ListObjet[] ;
extern T_SORT ListTri[] ;
extern WORD NumObjFollow ;
/*--------- ambiance ----------------------------*/
extern WORD SampleAmbiance[] ;
extern WORD SampleRepeat[] ;
extern WORD SampleRnd[] ;
extern WORD SamplePlayed ;
extern ULONG TimerNextAmbiance ;
extern WORD SecondEcart ;
extern WORD SecondMin ;
extern WORD CubeJingle ;
extern UBYTE *PtrXmi ;
extern WORD NumXmi ;
/*-------- Brick ISO ---------------------------------------------*/
#ifdef BRICK_HQR
extern UBYTE *BufferBrick ;
#endif
extern UBYTE *BufCube ;
extern WORD FirstTime ;
extern WORD CameraZone ;
extern LONG StartXCube ;
extern LONG StartYCube ;
extern LONG StartZCube ;
extern LONG WorldXCube ;
extern LONG WorldYCube ;
extern LONG WorldZCube ;
extern WORD XpOrgw ;
extern WORD YpOrgw ;
extern WORD LastXmBrickSelected ;
extern WORD LastYmBrickSelected ;
extern WORD LastZmBrickSelected ;
extern UBYTE *BufCollis ;
extern WORD CubeClip ;
extern WORD CubeClipX, CubeClipY, CubeClipZ ;
extern WORD FlagAffGrille ;
/*--------- Message ---------------------------------------------*/
extern WORD NumObjSpeak ;
extern LONG FlagSpeak ;

259
SOURCES/DEFINES.H Normal file
View File

@@ -0,0 +1,259 @@
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
ÛßßßÜ Ûßßßß Ûßßßß Û ÛÛÜ Û Ûßßßß ÛÛßßß
ÛÛ Û ÛÛßß ÛÛßß ÛÛ ÛÛßÛÛ ÛÛßß ßßßßÛ
ßßßß ßßßßß ßß ßß ßß ß ßßßßß ßßßßß
*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
// Cdrom Version si pas define version disk
//#define CDROM 1
// mettre ce define pour une version travail seulement
// en cdrom pas d'importance ATTENTION … supprimer pour version disk
// #define MAGOUILLE_FLA_HD 1
/*----------------*/
// demo 3 cubes
// #define DEMO 1
// sauvegarde ecran/acceleration/infos
//#define DEBUG_TOOLS 1
/*----------------*/
// Brick, Gri et Bll dans .HQR
#define BRICK_HQR 1
// samples dans .HQR
#define SAMPLE_HQR 1
// midi music dans .HQR
#define MIDI_HQR 1
// samples des FLAs dans .HQR
#define SAMPLE_FLA_HQR 1
// tous fichiers dans mˆme dir
#define ONE_GAME_DIRECTORY 1
//path des ressources
#define PATH_RESSOURCE ""
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
#include <stdlib.h>
#include <string.h>
#include <dos.h>
#include <conio.h>
#include <stdio.h>
#include "\projet\lib386\lib_sys\adeline.h"
#include "\projet\lib386\lib_sys\lib_sys.h"
#include "\projet\lib386\lib_svga\lib_svga.h"
#include "\projet\lib386\lib_3D\lib_3D.h"
#include "\projet\lib386\lib_mix\lib_mix.h"
#include "\projet\lib386\lib_samp\lib_wave.h"
#include "\projet\lib386\lib_midi\lib_midi.h"
#include "\projet\lib386\lib_cd\lib_cd.h"
#include "common.h"
/*---------------- macros ------------------*/
#ifdef DEBUG_TOOLS
extern ULONG UsedHQMemory ;
#define CHECK_MEMORY \
if( (Size_HQM_Memory-Size_HQM_Free) > UsedHQMemory )\
{\
UsedHQMemory = Size_HQM_Memory-Size_HQM_Free ;\
}
#else
#define CHECK_MEMORY /* coucou */
#endif
/*---------------- CONSTANTE ------------------*/
#define SIZE_CUBE_X 64
#define SIZE_CUBE_Y 25
#define SIZE_CUBE_Z 64
#define SIZE_BRICK_XZ 512
#define SIZE_BRICK_Y 256
#define DEMI_BRICK_XZ 256
#define DEMI_BRICK_Y 128
/*---------------- FENETRE ------------------*/
#define VIEW_X0 -50
#define VIEW_Y0 -30
#define VIEW_X1 680
#define VIEW_Y1 580
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
#define MAX_CLOVER_BOX 10
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
/* type objet pour affscene */
#define TYPE_OBJ_3D (1024*0)
#define TYPE_FLAG_RED (1024*1)
#define TYPE_FLAG_YELLOW (1024*2)
#define TYPE_SHADOW (1024*3)
#define TYPE_OBJ_SPRITE (1024*4)
#define TYPE_ZONE_DEC (1024*5)
#define TYPE_EXTRA (1024*6)
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
#define FILE_3D_NORMAL 0
#define FILE_3D_SPORTIF 1
#define FILE_3D_AGRESSIF 2
#define FILE_3D_DISCRET 3
#define FILE_3D_PROTOPACK 4
#define NO_BODY 255
#define GEN_BODY_NORMAL 0
#define GEN_BODY_TUNIQUE 1
#define GEN_BODY_SABRE 2
#define NO_ANIM 255
#define GEN_ANIM_RIEN 0
#define GEN_ANIM_MARCHE 1
#define GEN_ANIM_RECULE 2
#define GEN_ANIM_GAUCHE 3
#define GEN_ANIM_DROITE 4
#define GEN_ANIM_ENCAISSE 5
#define GEN_ANIM_CHOC 6
#define GEN_ANIM_TOMBE 7
#define GEN_ANIM_RECEPTION 8
#define GEN_ANIM_RECEPTION_2 9
#define GEN_ANIM_MORT 10
#define GEN_ANIM_ACTION 11
#define GEN_ANIM_MONTE 12
#define GEN_ANIM_ECHELLE 13
#define GEN_ANIM_SAUTE 14
#define GEN_ANIM_LANCE 15
#define GEN_ANIM_CACHE 16
#define GEN_ANIM_COUP_1 17
#define GEN_ANIM_COUP_2 18
#define GEN_ANIM_COUP_3 19
#define GEN_ANIM_TROUVE 20
#define GEN_ANIM_NOYADE 21
#define GEN_ANIM_CHOC2 22
#define GEN_ANIM_SABRE 23
#define GEN_ANIM_DEGAINE 24
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
typedef struct
{
UBYTE GenBody ; // 0 … 254 mais je veux -1
UBYTE GenAnim ;
UBYTE NextGenAnim ;
UBYTE Col ; /* brick en collision (inutile?) */
UBYTE *PtrAnimAction ;
WORD Sprite ;
WORD OffsetLabelTrack ;
// divers
UBYTE *PtrFile3D ;
// constantes
WORD OptionFlags ; /* flag d'init 2 */
/* B*/ WORD NbBonus ; /* nb bonus to give */
/* B*/ WORD Armure ; /* resistance */
WORD CoulObj ; /* couleur dominante de l'objet */
/* game infos */
WORD Body ; /* num body ou sprite dans la base */
WORD PosObjX ; /* pos world en cours */
WORD PosObjY ;
WORD PosObjZ ;
WORD OldPosX ; /* old pos world */
WORD OldPosY ;
WORD OldPosZ ;
WORD Xmin ; /* ZV */
WORD Xmax ;
WORD Ymin ;
WORD Ymax ;
WORD Zmin ;
WORD Zmax ;
WORD Beta ; /* angle en cours */
WORD SRot ; /* vitesse de rotation */
T_REAL_VALUE RealAngle ; /* valeur real time de rotation */
/* B*/ WORD Move ; /* type de deplacement */
UBYTE *PtrTrack ; /* ptr track prog */
WORD OffsetTrack ; /* offset dans la track */
UBYTE *PtrLife ;
WORD OffsetLife ; /* offset dans la vie */
WORD Info ; /* infos pour DoDir */
WORD Info1 ;
WORD Info2 ;
WORD Info3 ;
/* B*/ WORD ObjCol ; /* num obj en collision */
/* B*/ WORD CarryBy ;
WORD ZoneSce ; /* zone declenchement scenarique */
/* B*/ WORD LabelTrack ; /* dernier label de track */
/* B*/ WORD MemoLabelTrack ; /* memo dernier label de track */
WORD Flags ; /* flags divers permanent */
WORD WorkFlags ; /* flags de gestion */
/* B*/ WORD HitBy ; /* frappe par */
/* B*/ WORD HitForce ; /* si !=0 force de frappe anim */
/* B*/ WORD LifePoint ; /* point de vie en cours */
/* B*/ WORD AnimStepBeta ; /* step de rotation par anim */
WORD AnimStepX ; /* step de dep par anim */
WORD AnimStepY ;
WORD AnimStepZ ;
WORD DoorWidth ; // pour les DOOR peut reservir
WORD Anim ; /* anim en cours */
/* B*/ WORD Frame ; /* frame en cours */
/* B*/ WORD FlagAnim ; /* type d'anim en cours (dans flags?) */
UBYTE CodeJeu ; // brick sp‚ciale sample ou action
} T_OBJET ;
/*
typedef struct
{
UBYTE Bit ; } T_FLAG ;
*/
typedef struct
{
WORD X ;
WORD Y ;
WORD Z ; } T_TRACK ;

228
SOURCES/DISKFUNC.C Normal file
View File

@@ -0,0 +1,228 @@
#include "c_extern.h"
#include "direct.h"
#include <dos.h>
UBYTE *PtrSce ;
UBYTE *PtrScene ;
#define GET_BYTE (*PtrSce++)
#define GET_WORD (*(WORD*)PtrSce) ; PtrSce+=2
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
ÛßßßÜ Û ÛÛßßß Û Üß Ûßßßß Û Û ÛÛÜ Û Ûßßßß
ÛÛ Û ÛÛ ßßßßÛ ÛÛßÜ ÛÛßß ÛÛ Û ÛÛßÛÛ ÛÛ
ßßßß ßß ßßßßß ßß ß ßßßßß ßß ßßßßß ßß ß ßßßßß
*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
void GetDiskEnv( UBYTE *progpath )
{
_splitpath( (char*)progpath, ProgDrive, ProgDir, Name, Ext ) ;
getcwd( OrgDir, _MAX_DIR ) ;
_dos_getdrive( &OrgDrive ) ;
}
void RestoreDiskEnv()
{
ULONG total ;
_dos_setdrive( OrgDrive, &total ) ;
chdir( OrgDir ) ;
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
ÛÛßßß Ûßßßß Ûßßßß ÛÛÜ Û Ûßßßß Ûßßßß Û Û Ûßßßß
ßßßßÛ ÛÛ ÛÛßß ÛÛßÛÛ ÛÛßß ÛÛßß ÛÛ ÛÛ ÛÛßß
ßßßßß ßßßßß ßßßßß ßß ß ßßßßß ßßßßß ßß ßß ßßßßß ßßßßß
*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
WORD LoadScene( WORD numscene )
{
T_OBJET *ptrobj ;
WORD n, info3 ;
UBYTE string[256] ;
UBYTE mess[256] ;
WORD sizetoload ;
WORD indexfile3d ;
// PtrScene = PtrSce = LoadMalloc_HQR( PATH_RESSOURCE"scene.hqr", numscene ) ;
HQRM_Load( PATH_RESSOURCE"scene.hqr", numscene, &PtrScene ) ;
CHECK_MEMORY
PtrSce = PtrScene ;
if( !PtrSce )
{
Message( "Scene.Hqr introuvable ou pas assez mem", TRUE ) ;
}
// info world: INFO_WORLD
NewCube = numscene ;
Island = GET_BYTE ;
GameOverCube = GET_BYTE ;
n = GET_WORD ;
n = GET_WORD ;
// ListHoloObj[NUM_PERSO].Alpha = GET_WORD ;
// ListHoloObj[NUM_PERSO].Beta = GET_WORD ;
// ListHoloObj[NUM_PERSO].Size = GET_WORD ;
// ambiance: AMBIANCE
AlphaLight = GET_WORD ;
BetaLight = GET_WORD ;
SampleAmbiance[0] = GET_WORD ;
SampleRepeat[0] = GET_WORD ;
SampleRnd[0] = GET_WORD ;
SampleAmbiance[1] = GET_WORD ;
SampleRepeat[1] = GET_WORD ;
SampleRnd[1] = GET_WORD ;
SampleAmbiance[2] = GET_WORD ;
SampleRepeat[2] = GET_WORD ;
SampleRnd[2] = GET_WORD ;
SampleAmbiance[3] = GET_WORD ;
SampleRepeat[3] = GET_WORD ;
SampleRnd[3] = GET_WORD ;
SecondMin = GET_WORD ;
SecondEcart = GET_WORD ;
CubeJingle = GET_BYTE ;
// PlayMidiFile( CubeJingle ) ;
// hero inits: HERO_START
ptrobj = ListObjet ;
CubeStartX = GET_WORD ;
CubeStartY = GET_WORD ;
CubeStartZ = GET_WORD ;
sizetoload = GET_WORD ;
ptrobj->PtrTrack = PtrSce ;
PtrSce += sizetoload ;
sizetoload = GET_WORD ;
ptrobj->PtrLife = PtrSce ;
PtrSce += sizetoload ;
ptrobj++ ;
// objets: OBJECT
NbObjets = GET_WORD ;
for( n=1; n<NbObjets; n++, ptrobj++ )
{
InitObject( n ) ;
ptrobj->Flags = GET_WORD ;
indexfile3d = GET_WORD ;
if( !(ptrobj->Flags & SPRITE_3D) )
{
HQRM_Load( PATH_RESSOURCE"File3D.hqr", indexfile3d, &ptrobj->PtrFile3D ) ;
CHECK_MEMORY
/* ptrobj->PtrFile3D =
LoadMalloc_HQR(
PATH_RESSOURCE"File3D.hqr",
indexfile3d ) ;
*/
}
ptrobj->GenBody = GET_BYTE ;
ptrobj->GenAnim = GET_BYTE ;
/*
if( n==5 )
{
CoulText( 15,0 ) ;
Text( 10, 300, "obj 5 org anim: %d", ptrobj->GenAnim ) ;
}
*/
ptrobj->Sprite = GET_WORD ;
ptrobj->OldPosX = ptrobj->PosObjX = GET_WORD ;
ptrobj->OldPosY = ptrobj->PosObjY = GET_WORD ;
ptrobj->OldPosZ = ptrobj->PosObjZ = GET_WORD ;
ptrobj->HitForce = GET_BYTE ;
ptrobj->OptionFlags = GET_WORD ;
ptrobj->OptionFlags &= ~EXTRA_GIVE_NOTHING ;
ptrobj->Beta = GET_WORD ;
ptrobj->SRot = GET_WORD ;
ptrobj->Move = GET_WORD ;
ptrobj->Info = GET_WORD ;
ptrobj->Info1 = GET_WORD ;
ptrobj->Info2 = GET_WORD ;
ptrobj->Info3 = GET_WORD ;
ptrobj->NbBonus = GET_BYTE ;
ptrobj->CoulObj = GET_BYTE ;
ptrobj->Armure = GET_BYTE ;
ptrobj->LifePoint = GET_BYTE ;
sizetoload = GET_WORD ;
ptrobj->PtrTrack = PtrSce ;
PtrSce = PtrSce + sizetoload ;
sizetoload = GET_WORD ;
ptrobj->PtrLife = PtrSce ;
PtrSce = PtrSce + sizetoload ;
}
// zone declechement: ZONE
NbZones = GET_WORD ;
ListZone = (T_ZONE*)PtrSce ;
PtrSce += NbZones * 12 * 2 ;
// point track: TRACK
NbBrickTrack = GET_WORD ;
ListBrickTrack = (T_TRACK*)PtrSce ;
return TRUE ;
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
ÛßßßÜ Ûßßßß ÛßßÛ Û Û Ûßßßß
ÛÛ Û ÛÛßß ÛÛßßÛ ÛÛ Û ÛÛ ßÛ
ßßßß ßßßßß ßßßßß ßßßßß ßßßßß
*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
/*
void *LoadTestMalloc( char *filename )
{
void *ptr ;
UBYTE string[256] ;
ptr = LoadMalloc( filename ) ;
if( !ptr )
{
strcpy( string, "ARG ! Mem:" ) ;
strcat( string, Itoa( (ULONG)Malloc(-1) ) ) ;
strcat( string, " fichier:" ) ;
strcat( string, filename ) ;
Message( string, TRUE ) ;
}
return ptr ;
}
*/
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/

3
SOURCES/DISKFUNC.DEF Normal file
View File

@@ -0,0 +1,3 @@
extern void GetDiskEnv(unsigned char *);
extern void RestoreDiskEnv(void);
extern short LoadScene(short );

1275
SOURCES/EXTRA.C Normal file
View File

File diff suppressed because it is too large Load Diff

21
SOURCES/EXTRA.DEF Normal file
View File

@@ -0,0 +1,21 @@
extern void InitFly(T_EXTRA *,short ,short ,short ,short );
extern void BounceExtra(T_EXTRA *,short ,short ,short );
extern short ExtraBonus(short ,short ,short ,short ,short ,short ,short );
extern short ExtraExplo(short ,short ,short );
extern short SearchBonusKey(void);
extern short ExtraSearch(short ,short ,short ,short ,short ,short ,short ,short );
extern short ExtraSearchKey(short ,short ,short ,short ,short ,short );
extern short ExtraCheckObjCol(T_EXTRA *,short );
extern short ExtraCheckExtraCol(T_EXTRA *,short );
extern unsigned char FullWorldColBrick(short ,short ,short ,short ,short ,short );
extern void ClearScreenMinMax(void);
extern void AdjustScreenMax(void);
extern void Aff2DShape(short *,short ,short ,short ,short ,short );
extern void AffSpecial(short ,short ,short );
extern void InitSpecial(short ,short ,short ,short );
extern long CoulRetourBalle(T_EXTRA *);
extern void ClearExtra(void);
extern short ThrowExtra(short ,short ,short ,short ,short ,short ,short ,short ,short ,short );
extern void GiveExtraBonus(T_OBJET *);
extern void ZoneGiveExtraBonus(T_ZONE *);
extern void GereExtras(void);

689
SOURCES/FICHE.C Normal file
View File

@@ -0,0 +1,689 @@
#include "c_extern.h"
#include <dos.h>
#ifdef COMPILATOR
extern UBYTE *PtrCompil ;
extern WORD FlagCompilator ;
#endif
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
ÛÛßßß Ûßßßß ÛßßßÛ Û ÛßßßÛ ßßÛßß
ßßßßÛ ÛÛ ÛÛßÛß ÛÛ ÛÛßßß ÛÛ
ßßßßß ßßßßß ßß ß ßß ßß ßß
*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
WORD SearchBonusKey() ;
UBYTE *SearchPtrAnimAction ;
WORD M_Xmin = -32000 ;
WORD M_Xmax, M_Ymin, M_Ymax, M_Zmin, M_Zmax ;
UBYTE MagicHitForce[] = { 2, 3, 4, 6, 8 } ;
#define BASE_STEP_SOUND 126
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void ThrowMagicBall( WORD x, WORD y, WORD z,
WORD alpha, WORD beta,
WORD vitesse, UBYTE poids )
{
UBYTE sprite ;
UBYTE force ;
WORD search ;
/* ici on determine le type de tir et la force */
switch( MagicLevel )
{
case 0:
case 1:
sprite = 1 ;
force = 4 ;
break ;
case 2:
sprite = 42 ;
force = 6 ;
break ;
case 3:
sprite = 43 ;
force = 8 ;
break ;
case 4:
sprite = 13 ;
force = 10 ;
break ;
}
MagicBallType = ((MagicPoint-1) / 20) + 1 ;
if( MagicPoint == 0 ) MagicBallType = 0 ;
// si clef trouv‚e
if( (search = SearchBonusKey()) != -1 )
{
MagicBallType = 5 ;
}
switch( MagicBallType )
{
case 0: // balle normale directe
MagicBall =
ThrowExtra( NUM_PERSO, x,y,z,
sprite,
alpha, beta,
vitesse, poids,
force ) ;
break ;
case 1: // balle qui rebondit
MagicBallCount = 4 ;
MagicBall =
ThrowExtra( NUM_PERSO, x,y,z,
sprite,
alpha, beta,
vitesse, poids,
force ) ;
break ;
case 2: // balle qui rebondit
MagicBallType = 1 ;
MagicBallCount = 4 ;
MagicBall =
ThrowExtra( NUM_PERSO, x,y,z,
sprite,
alpha, beta,
vitesse, poids,
force ) ;
break ;
case 3: // balle qui rebondit
MagicBallType = 1 ;
MagicBallCount = 4 ;
MagicBall =
ThrowExtra( NUM_PERSO, x,y,z,
sprite,
alpha, beta,
vitesse, poids,
force ) ;
break ;
case 4: // balle qui rebondit
MagicBallType = 1 ;
MagicBallCount = 4 ;
MagicBall =
ThrowExtra( NUM_PERSO, x,y,z,
sprite,
alpha, beta,
vitesse, poids,
force ) ;
break ;
case 5: // cherche Key
MagicBall = ExtraSearchKey( NUM_PERSO, x,y,z,
sprite, search ) ;
break ;
}
// la balle magique coute 1 point de magie
if( MagicPoint > 0 ) MagicPoint-- ;
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*----------------------------------------------------------------------*/
/* recherche des options d'anims */
#define GET_BYTE (*ptrc++)
#define GET_WORD (*(WORD*)ptrc) ; ptrc+=2
void GereAnimAction( T_OBJET *ptrobj, WORD numobj )
{
WORD sample ;
WORD decal ;
WORD anim ;
WORD point, x,y,z ;
WORD sprite ;
WORD alpha ;
WORD beta ;
WORD vitesse ;
WORD poids ;
WORD force ;
WORD repeat ;
WORD search ;
WORD dist ;
WORD balltype ;
UBYTE *ptrc ;
WORD n, nb ;
anim = ptrobj->Anim ;
ptrc = ptrobj->PtrAnimAction ;
nb = *ptrc++ ;
for( n=0; n<nb; n++ )
{
switch( *ptrc++ )
{
case 5: /* hit */
if( ptrobj->Frame == *ptrc++ - 1 )
{
ptrobj->HitForce = GET_BYTE ;
ptrobj->WorkFlags |= OK_HIT ;
}
else ptrc++ ;
break ;
case 6: /* sample */
// Message( "Sample Action", FALSE ) ;
if( ptrobj->Frame == *ptrc++ )
{
HQ_3D_MixSample( *(WORD*)ptrc, 0x1000, 1,
ptrobj->PosObjX, ptrobj->PosObjY, ptrobj->PosObjZ ) ;
}
ptrc += 2 ;
break ;
case 7: /* sample_rnd */
if( ptrobj->Frame == *ptrc++ )
{
sample = GET_WORD ;
decal = GET_WORD ;
HQ_3D_MixSample( sample, 0x1000+Rnd(decal)-(decal/2), 1,
ptrobj->PosObjX, ptrobj->PosObjY, ptrobj->PosObjZ ) ;
}
else ptrc += 4 ;
break ;
case 8: /* throw */
if( ptrobj->Frame == *ptrc++ )
{
point = GET_WORD ;
sprite = GET_BYTE ;
alpha = GET_WORD ;
beta = ptrobj->Beta + GET_WORD ;
vitesse = GET_WORD ;
poids = GET_BYTE ;
force = GET_BYTE ;
ThrowExtra( numobj,
ptrobj->PosObjX,ptrobj->PosObjY+point,ptrobj->PosObjZ,
sprite,
alpha, beta, vitesse, poids,
force ) ;
}
else ptrc += 11 ;
break ;
case 9: /* throw_magic */
if( MagicBall == -1 ) // pas de balle en cours
{
if( ptrobj->Frame == *ptrc++ ) // frame ok ?
{
point = GET_WORD ;
alpha = GET_WORD ;
vitesse = GET_WORD ;
poids = GET_BYTE ;
ThrowMagicBall( ptrobj->PosObjX,
ptrobj->PosObjY + point,
ptrobj->PosObjZ,
alpha,
ptrobj->Beta,
vitesse,
poids ) ;
}
else ptrc += 7 ;
}
else ptrc += 8 ;
break ;
case 10: /* sample_repeat */
if( ptrobj->Frame == *ptrc++ )
{
sample = GET_WORD ;
repeat = GET_WORD ;
HQ_3D_MixSample( sample, 0x1000, repeat,
ptrobj->PosObjX, ptrobj->PosObjY, ptrobj->PosObjZ ) ;
}
else ptrc += 4 ;
break ;
case 11: /* throw_search */
if( ptrobj->Frame == *ptrc++ )
{
point = GET_WORD ;
sprite = GET_BYTE ;
search = GET_BYTE ;
vitesse = GET_WORD ;
force = GET_BYTE ;
ExtraSearch( numobj, ptrobj->PosObjX,ptrobj->PosObjY+point,ptrobj->PosObjZ,
sprite,
search, vitesse, force ) ;
}
else ptrc += 6 ;
break ;
case 12: /* throw_alpha */
if( ptrobj->Frame == *ptrc++ )
{
dist = Distance2D(ptrobj->PosObjX,
ptrobj->PosObjZ,
ListObjet[NUM_PERSO].PosObjX,
ListObjet[NUM_PERSO].PosObjZ ) ;
alpha = GetAngle(ptrobj->PosObjY,0,
ListObjet[NUM_PERSO].PosObjY,
dist ) ;
point = GET_WORD ;
sprite = GET_BYTE ;
alpha += GET_WORD ;
beta = ptrobj->Beta + GET_WORD ;
vitesse = GET_WORD ;
poids = GET_BYTE ;
force = GET_BYTE ;
ThrowExtra( numobj,
ptrobj->PosObjX,ptrobj->PosObjY+point,ptrobj->PosObjZ,
sprite,
alpha, beta, vitesse, poids,
force ) ;
}
else ptrc += 11 ;
break ;
case 13: /* sample_stop */
if( ptrobj->Frame == *ptrc++ )
{
sample = GET_WORD ;
HQ_StopOneSample( sample ) ;
}
else ptrc += 2 ;
break ;
case 15: // left_step
if( ptrobj->Frame == *ptrc++ ) /* frame */
{
/* sample = WorldCodeBrick( ptrobj->PosObjX,
ptrobj->PosObjY-1,
ptrobj->PosObjZ ) ;
*/
sample = ptrobj->CodeJeu ;
if( sample != 0xF0 ) // rien
{
if( (sample & 0xF0) == 0xF0 ) // code jeu
{
}
else
{
HQ_3D_MixSample( (sample>>4) + BASE_STEP_SOUND,
0x1000+Rnd(1000)-500,
1,
ptrobj->PosObjX, ptrobj->PosObjY, ptrobj->PosObjZ ) ;
}
}
}
break ;
case 16: // right_step
if( ptrobj->Frame == *ptrc++ )
{
/* sample = WorldCodeBrick( ptrobj->PosObjX,
ptrobj->PosObjY-1,
ptrobj->PosObjZ ) ;
*/
sample = ptrobj->CodeJeu ;
if( sample != 0xF0 ) // rien
{
if( (sample & 0xF0) == 0xF0 ) // code jeu
{
}
else
{
HQ_3D_MixSample(
(sample&0x0F) + BASE_STEP_SOUND + 15,
0x1000+Rnd(1000)-500,
1,
ptrobj->PosObjX, ptrobj->PosObjY, ptrobj->PosObjZ ) ;
}
}
}
break ;
case 17: /* hit_twinkel */
if( ptrobj->Frame == *ptrc++ - 1 )
{
ptrobj->HitForce = MagicHitForce[ MagicLevel ] ;
ptrobj->WorkFlags |= OK_HIT ;
}
break ;
case 18: /* throw_3D */
if( ptrobj->Frame == *ptrc++ )
{
x = GET_WORD ;
y = GET_WORD ;
z = GET_WORD ;
Rotate( x,z, ptrobj->Beta ) ;
x = X0 + ptrobj->PosObjX ;
y += ptrobj->PosObjY ;
z = Y0 + ptrobj->PosObjZ ;
sprite = GET_BYTE ;
alpha = GET_WORD ;
beta = ptrobj->Beta + GET_WORD ;
vitesse = GET_WORD ;
poids = GET_BYTE ;
force = GET_BYTE ;
ThrowExtra( numobj,
x,y,z,
sprite,
alpha, beta, vitesse, poids,
force ) ;
}
else ptrc += 15 ;
break ;
case 19: /* throw_3D_alpha */
if( ptrobj->Frame == *ptrc++ )
{
dist = Distance2D(ptrobj->PosObjX,
ptrobj->PosObjZ,
ListObjet[NUM_PERSO].PosObjX,
ListObjet[NUM_PERSO].PosObjZ ) ;
alpha = GetAngle(ptrobj->PosObjY,0,
ListObjet[NUM_PERSO].PosObjY,
dist ) ;
x = GET_WORD ;
y = GET_WORD ;
z = GET_WORD ;
Rotate( x,z, ptrobj->Beta ) ;
x = X0 + ptrobj->PosObjX ;
y += ptrobj->PosObjY ;
z = Y0 + ptrobj->PosObjZ ;
sprite = GET_BYTE ;
alpha += GET_WORD ;
beta = ptrobj->Beta + GET_WORD ;
vitesse = GET_WORD ;
poids = GET_BYTE ;
force = GET_BYTE ;
ThrowExtra( numobj,
x,y,z,
sprite,
alpha, beta, vitesse, poids,
force ) ;
}
else ptrc += 15 ;
break ;
case 20: /* throw_3D_search */
if( ptrobj->Frame == *ptrc++ )
{
x = GET_WORD ;
y = GET_WORD ;
z = GET_WORD ;
Rotate( x,z, ptrobj->Beta ) ;
x = X0 + ptrobj->PosObjX ;
y += ptrobj->PosObjY ;
z = Y0 + ptrobj->PosObjZ ;
sprite = GET_BYTE ;
search = GET_BYTE ;
vitesse = GET_WORD ;
force = GET_BYTE ;
ExtraSearch( numobj,
x,y,z,
sprite,
search, vitesse, force ) ;
}
else ptrc += 11 ;
break ;
case 21: /* throw_3D_magic */
if( MagicBall == -1 ) // pas de balle en cours
{
if( ptrobj->Frame == *ptrc++ )
{
x = GET_WORD ;
y = GET_WORD ;
z = GET_WORD ;
Rotate( x,z, ptrobj->Beta ) ;
x = X0 + ptrobj->PosObjX ;
y += ptrobj->PosObjY ;
z = Y0 + ptrobj->PosObjZ ;
alpha = GET_WORD ;
vitesse = GET_WORD ;
poids = GET_BYTE ;
ThrowMagicBall( x,y,z,
alpha,
ptrobj->Beta,
vitesse,
poids ) ;
}
else ptrc += 11 ;
}
else ptrc += 12 ;
break ;
default:
return ;
}
}
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
WORD SearchAnim( UBYTE numanim, WORD numobj )
{
UBYTE command ;
T_OBJET *ptrobj ;
WORD hqranim ;
UBYTE *ptrc ;
UBYTE numgene ;
ptrobj = &ListObjet[numobj] ;
ptrc = ptrobj->PtrFile3D ;
SearchPtrAnimAction = 0 ;
while( (command = *ptrc++) != 255 )
{
switch( command )
{
case 3: /* ANIM */
numgene = *ptrc++ ; // lit num name generique
if( numanim == numgene ) // ok trouve
{
ptrc++ ; // saute size anim
hqranim = *(WORD*)ptrc ;
/*if( numobj==2)
{
CoulText( 15, 0 ) ;
Text( 10,110, "%FSearchAnim GenAnim:%d HqrAnim:%d ", numanim, hqranim ) ;
}*/
ptrc += 2 ;
if( *ptrc++ ) // anim possede action ?
{
SearchPtrAnimAction = ptrc-1 ;
}
return hqranim ;
}
else
{
ptrc += *ptrc ; // next anim
}
break ;
default:
ptrc++ ; // gen
ptrc += *ptrc ;
}
}
return -1 ;
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
WORD SearchBody( UBYTE numbody, WORD numobj )
{
UBYTE command ;
T_OBJET *ptrobj ;
UWORD hqrbody ;
UBYTE *ptrc ;
UBYTE numgene ;
ptrobj = &ListObjet[numobj] ;
ptrc = ptrobj->PtrFile3D ;
/* if( (numobj == NUM_PERSO)
AND (numbody == GEN_BODY_NORMAL)
AND (Weapon == 1) )
{
numbody = GEN_BODY_SABRE ;
}
*/
while( (command = *ptrc++) != 255 )
{
switch( command )
{
case 1: /* BODY */
numgene = *ptrc++ ; // lit num name generique
if( numbody == numgene ) // ok trouve
{
ptrc++ ; // saute size body
hqrbody = *(UWORD*)ptrc ;
if( hqrbody & (1<<15) ) // already loaded
{
hqrbody &= ~(1<<15) ;
//CoulText( 15, 0 ) ;
//Text( 10,110, "%FSearchBody d‚j… charg‚ %d", hqrbody ) ;
}
else
{
//Text( 10,120, "%FSearchBody new %d", hqrbody ) ;
HQRM_Load( PATH_RESSOURCE"body.hqr", hqrbody, &PtrBody[NbBodys] ) ;
CHECK_MEMORY
/* PtrBody[NbBodys]
= LoadMalloc_HQR(
PATH_RESSOURCE"body.hqr",
hqrbody ) ;
*/
if( !PtrBody[NbBodys] ) TheEnd( NOT_ENOUGH_MEM, "Body.HQR in HQ_Mem" ) ;
PatchObjet( PtrBody[NbBodys] ) ;
hqrbody = NbBodys ;
NbBodys++ ;
//Text( 10,130, "%FNbBodys %d", NbBodys ) ;
*(UWORD*)ptrc = hqrbody + (1<<15) ;
}
ptrc += 2 ;
M_Xmin = -32000 ;
if( *ptrc++ ) // body possede action ?
{
if( *ptrc++ == 14 ) // ZV
{
M_Xmin = *(WORD*)ptrc ;
ptrc += 2 ;
M_Ymin = *(WORD*)ptrc ;
ptrc += 2 ;
M_Zmin = *(WORD*)ptrc ;
ptrc += 2 ;
M_Xmax = *(WORD*)ptrc ;
ptrc += 2 ;
M_Ymax = *(WORD*)ptrc ;
ptrc += 2 ;
M_Zmax = *(WORD*)ptrc ;
ptrc += 2 ;
}
}
return hqrbody ;
}
else
{
ptrc += *ptrc ; // next body
}
break ;
default:
ptrc++ ; // gen
ptrc += *ptrc ;
}
}
return -1 ;
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*
void LoadFic( UBYTE indexfileobjet, WORD numobj )
{
T_OBJET *ptrobj ;
LONG size ;
ptrobj = &ListObjet[numobj] ;
ptrobj->PtrFile3D = LoadMalloc_HQR(
PATH_RESSOURCE"FILE3D.HQR",
indexfileobjet ) ;
}
*/
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/

4
SOURCES/FICHE.DEF Normal file
View File

@@ -0,0 +1,4 @@
extern void ThrowMagicBall(short ,short ,short ,short ,short ,short ,unsigned char );
extern void GereAnimAction(T_OBJET *,short );
extern short SearchAnim(unsigned char ,short );
extern short SearchBody(unsigned char ,short );

177
SOURCES/FIRE.ASM Normal file
View File

@@ -0,0 +1,177 @@
; ------------------------------ FIRE.ASM ------------------------------
.386p
.model SMALL, SYSCALL
.data
include \projet\lib386\lib_svga\svga.ash
include \projet\lib386\lib_sys\lib_sys.ash
public NoLanguage Imagen
extrn NoLanguage BufSpeak:DWORD
;Imagen DB 320*50 DUP (0)
;Imagen2 DB 320*50 DUP (0)
Imagen dd 0000
Imagen2 dd 0000
loopy dw 00
.code
public NoLanguage DoFire
public NoLanguage ComputeFire
ComputeFire proc uses esi edi ebx edx
mov eax, [BufSpeak]
mov [Imagen], eax
add eax, 320*50
mov [Imagen2], eax
mov esi, [Imagen]
add esi, 321
mov edi, [Imagen2]
add edi, 321
; mov esi, 321 + offset Imagen
; mov edi, 321 + offset Imagen2
MOV CX,48*320-2
XOR BH,BH
@@lp:
XOR AX,AX
ADD AL,-1[eSI]
ADC AH,BH
ADD AL,-320[eSI]
ADC AH,BH
ADD AL,-319[eSI]
ADC AH,BH
ADD AL,-321[eSI]
ADC AH,BH
ADD AL,1[eSI]
ADC AH,BH
ADD AL,320[eSI]
ADC AH,BH
ADD AL,319[eSI]
ADC AH,BH
ADD AL,321[eSI]
ADC AH,BH
ROR AX,3
TEST AH,65h ; Wanna know why 60h? Me too.
JNZ @@nx ; This is pure experience.
; ok but it's better with 65
mov edx, [Imagen2]
add edx, 46*320
CMP edi, edx
; cmp edi, 46*320 + offset Imagen2
JNC @@dec
OR AL,AL ; My dog coded here too.
JZ @@nx ; I helped my sister with this one.
@@dec:
DEC AL ; Yeah! Cool a bit, please.
@@nx:
inc esi
mov byte ptr[edi], al
inc edi
dec cx
jnz @@lp ; New image stored in Imagen2.
mov esi, [Imagen2]
add esi, 320
MOV edi, [Imagen]
; mov esi, 320 + offset Imagen2
; mov edi, offset Imagen
MOV ecx, 160*48/2
rep movsd
mov esi, [Imagen2]
add esi, 320*39
; mov esi, offset Imagen2 + 320*39
mov ecx, 5*320
mov ah, 11
@@rcl:
mov al,[esi]
cmp al, 15
jnc @@rcn
SUB AL,AH
NEG AL
MOV [eSI],AL
@@rcn:
INC eSI
dec cx
jnz @@rcl
ret
ComputeFire endp
DoFire proc uses esi edi ebx ebp ,\
lig:dword, coul:dword
call ComputeFire
mov esi, [Imagen]
add esi, 5*320
; mov esi, offset Imagen + 5 * 320
mov edi, Log
mov eax, lig
add edi, [TabOffLine + eax*4]
mov ebx, Coul
mov bh, bl
add bh, 15
mov dx, 25
copy0: mov cx, 320
copy: mov al, [esi]
shr al, 1
add al, bl
cmp al, bh
ja adcoul
adcrt: mov ah, al
mov [edi], ax
mov [edi+640], ax
inc esi
inc edi
inc edi
dec cx
jnz copy
add edi, 640
dec dx
jnz copy0
ret
adcoul: mov al, bh
jmp adcrt
DoFire endp
END

138
SOURCES/FLA.H Normal file
View File

@@ -0,0 +1,138 @@
#include "\projet\lib386\lib_X\lib_X.h"
#define MAX_SAMPLES_FLA 255
#define NOM_FICHIER_DEF_CONFIGURATION "C:\\ADELINE.DEF"
#ifdef ONE_GAME_DIRECTORY
#define PATH_FICHIER_SAMPLE "FLA\\"
#else
#define PATH_FICHIER_SAMPLE "F:\\projet\\lba\\samples\\flasamp\\"
#endif
#define NOM_FICHIER_TEMPORAIRE "Fla_"
#define NOM_FICHIER_FRAME_TEMPORAIRE "C:\\_Frame.tmp"
#define FLI 2
#define FLA 3
#define X_POS_MENU_PRINCIPAL 480
#define Y_POS_MENU_PRINCIPAL 10
#define X_POS_MENU_STORYBOARD 0
#define Y_POS_MENU_STORYBOARD 335
// Define pour les fichiers format FLI
#define FLI_COLOR 11
#define FLI_LC 12
#define FLI_BLACK 13
#define FLI_BRUN 15
#define FLI_COPY 16
// Structures utilis‚es pour les fichiers format FLI
typedef struct
{
LONG size ;
UWORD type ;/* = FLIH_MAGIC */
UWORD frame_count ;
UWORD width ;
UWORD height ;
UWORD bits_a_pixel ;
WORD flags ;
WORD speed ;
LONG next_head ;
LONG frames_in_table ;
WORD file ;
LONG frame1_off ;
LONG strokes ;
LONG session ;
BYTE reserved[88] ;
} T_HEADER_FLI ;
typedef struct
{
ULONG size ;
UWORD typedata ;
UBYTE image[] ;
} T_HEADER_IMAGE ;
typedef struct
{
ULONG offset ;
UWORD signature ;
UWORD nbpasse ;
UBYTE reserved[6+2] ;
} T_HEADER_SUB ;
// Define pour les fichiers format FLA
#define VERSION "V1.3"
#define FLA_PALETTE 1
#define FLA_INFO 2
#define FLA_SAMPLE 3
#define FLA_SAMPLE_BALANCE 4
#define FLA_SAMPLE_STOP 5
#define FLA_LC 6
#define FLA_BLACK 7
#define FLA_BRUN 8
#define FLA_COPY 9
// Structures utilis‚es pour les fichiers format FLA
typedef struct // entete de fichier FLA
{
char Version[5] ;
ULONG NbFrame ;
UBYTE CadenceAnimation;
UWORD ResolutionX ;
UWORD ResolutionY ;
} T_HEADER_FLA;
typedef struct // header de passe
{
UBYTE NbPasse ;
ULONG OffsetFrameSuivante ;
} T_HEADER_FLA_PASSE;
typedef struct // structure d'un type de passe
{
UBYTE Type;
UWORD OffsetPasseSuivante;
} T_FLA_TYPE;
typedef struct // structure d'un element d'une liste de son
{
WORD NbSample;
WORD OffsetFrameOne;
} T_FLA_SAMPLE_LIST;
typedef struct // structure d'une info
{
WORD Info ;
} T_FLA_INFO;
typedef struct // structure d'un son
{
WORD Numero ;
WORD Decalage;
WORD Repetition;
UBYTE Balance;
UBYTE VolumeG;
UBYTE VolumeD;
} T_FLA_SAMPLE;
typedef struct // structure d'un son
{
WORD Numero ;
UBYTE Offset ;
WORD Balance ;
UBYTE VolumeG ;
UBYTE VolumeD ;
} T_FLA_BALANCE;
typedef struct // structure d'arret de son
{
UWORD Numero ;
} T_FLA_SAMPLE_STOP;
typedef struct // structure d'une palette
{
UWORD NbCouleur;
UWORD CouleurDepart;
} T_FLA_PALETTE;

140
SOURCES/FLIPBOX.C Normal file
View File

@@ -0,0 +1,140 @@
#include "defines.h"
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
Ûßßßß Û Û ÛßßßÛ ÛßßÛ ÛßßßÛ ßÜ Üß
ÛÛßß ÛÛ ÛÛ ÛÛßßß ÛÛßßÛ ÛÛ Û ÜßÜ
ßß ßßßßß ßß ßß ßßßßß ßßßßß ßßßßß ß ß
*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
extern UBYTE *Screen ; /* background clean */
typedef struct
{
WORD x0 ;
WORD y0 ;
WORD x1 ;
WORD y1 ; } T_PHYSBOX ;
T_PHYSBOX NewListBox[MAX_OBJETS+MAX_EXTRAS] ;
T_PHYSBOX OptListBox[(MAX_OBJETS+MAX_EXTRAS)*2] ;
WORD NbPhysBox = 0 ;
WORD NbOptPhysBox = 0 ;
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
void AddOptBox( WORD x0, WORD y0, WORD x1, WORD y1 )
{
T_PHYSBOX *ptr ;
WORD cx0, cy0, cx1, cy1 ;
WORD n ;
LONG totalsurface ;
LONG surfacecommune ;
LONG surfacetest ;
surfacetest = (x1-x0) * (y1-y0) ;
ptr = OptListBox ;
for( n=0; n<NbOptPhysBox; n++, ptr++ )
{
cx0 = min(ptr->x0,x0) ;
cx1 = max(ptr->x1,x1) ;
cy0 = min(ptr->y0,y0) ;
cy1 = max(ptr->y1,y1) ;
surfacecommune = (LONG)(cx1-cx0) * (cy1-cy0) ;
totalsurface = surfacetest + (ptr->x1-ptr->x0) * (ptr->y1-ptr->y0) ;
if( surfacecommune < totalsurface )
{
ptr->x0 = cx0 ;
ptr->y0 = cy0 ;
ptr->x1 = cx1 ;
ptr->y1 = cy1 ;
return ;
}
}
ptr->x0 = x0 ;
ptr->y0 = y0 ;
ptr->x1 = x1 ;
ptr->y1 = y1 ;
NbOptPhysBox++ ;
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
void AddPhysBox( WORD x0, WORD y0, WORD x1, WORD y1 )
{
T_PHYSBOX *ptr ;
if( x0 < 0 ) x0 = 0 ;
if( x1 > 639 ) x1 = 639 ;
if( y0 < 0 ) y0 = 0 ;
if( y1 > 479 ) y1 = 479 ;
if( x1 < x0 ) return ;
if( y1 < y0 ) return ;
ptr = &NewListBox[NbPhysBox] ;
ptr->x0 = x0 ;
ptr->y0 = y0 ;
ptr->x1 = x1 ;
ptr->y1 = y1 ;
NbPhysBox++ ;
AddOptBox( x0, y0, x1, y1 ) ;
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
void FlipOptList()
{
WORD n ;
T_PHYSBOX *ptr ;
/* regenere optlistbox pour clear log
puis phys a la prochaine boucle*/
ptr = NewListBox ;
NbOptPhysBox = 0 ;
for( n=0; n<NbPhysBox; n++,ptr++ )
{
AddOptBox( ptr->x0, ptr->y0, ptr->x1, ptr->y1 ) ;
}
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
void FlipBoxes()
{
WORD n ;
T_PHYSBOX *ptr ;
/* copie liste optimis‚e vers phys */
ptr = OptListBox ;
for( n=0; n<NbOptPhysBox; n++,ptr++ )
{
CopyBlockPhys( ptr->x0, ptr->y0, ptr->x1, ptr->y1 ) ;
}
FlipOptList() ;
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
void ClsBoxes()
{
WORD n ;
T_PHYSBOX *ptr ;
/* efface ecran logique (copy depuis Screen org) */
ptr = OptListBox ;
for( n=0; n<NbOptPhysBox; n++,ptr++ )
{
CopyBlock( ptr->x0, ptr->y0, ptr->x1, ptr->y1, Screen,
ptr->x0, ptr->y0, Log ) ;
/* Box( ptr->x0, ptr->y0, ptr->x1, ptr->y1, 0 ) ; */
}
}

5
SOURCES/FLIPBOX.DEF Normal file
View File

@@ -0,0 +1,5 @@
extern void AddOptBox(short ,short ,short ,short );
extern void AddPhysBox(short ,short ,short ,short );
extern void FlipOptList(void);
extern void FlipBoxes(void);
extern void ClsBoxes(void);

415
SOURCES/FUNC.ASM Normal file
View File

@@ -0,0 +1,415 @@
.386p
.model SMALL, SYSCALL
include f:\projet\lib386\lib_svga\svga.ash
;*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
;*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*
.data
;*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*
extrn NoLanguage TabOffLine:DWORD
extrn NoLanguage Screen:DWORD
IndexCoul0 db 4*16
PalRed db 0
PalGreen db 0
PalBlue db 0
PalXor db 0
;*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*
.code
;*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*
;*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
public NoLanguage SimpleInitMcga
public NoLanguage CopyBlockMCGA
public NoLanguage ShadeBox
public NoLanguage SmallSort
; public NoLanguage SpeedRam
; public NoLanguage TimerPalFx
public NoLanguage GetHDFreeSize
public NoLanguage ComputeTime
;*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
;SpeedRam proc ; pas remarquable
;
; mov al, 200
; out 41, al
; ret
;
;SpeedRam endp
;*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
comment #
TimerPalFx proc uses eax edx ecx
xor byte ptr[PalXor], 1
jnz tpf1
add byte ptr[PalBlue], 4
mov al, [IndexCoul0]
mov dx, 03c8h
out dx, al ; al=Num Color
mov ah, [PalBlue]
mov cx, 16
tpf0: mov dx, 03c9h
mov al, [PalRed]
out dx, al ; Red
mov al, [PalGreen]
out dx, al ; Green
mov al, ah
out dx, al ; Blue
add ah, 8
dec cx
jnz tpf0
tpf1: ret
TimerPalFx endp
#
;----------------------------------------------------------------------------
ComputeTime proc
local cpttime:DWORD
local cptdate:DWORD
mov [cpttime], 0
mov [cptdate], 0
mov ah, 2ch
int 21h
mov byte ptr [cpttime], ch ;'Heure
shl cpttime, 6
or byte ptr [cpttime], cl ;'Minutes
shl cpttime, 5
shr dh, 1
or byte ptr [cpttime], dh ;'Secondes/2
mov ah, 2ah
int 21h
sub cx, 1980
mov byte ptr [cptdate], cl ;' Annees
shl cptdate, 4
or byte ptr [cptdate], dh ;' Mois
shl cptdate, 5
or byte ptr [cptdate], dl ;' Jour
mov eax, cpttime
add eax, cptdate
ret
ComputeTime endp
;*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
SmallSort proc uses esi edi ebx ebp,\
objetlist:DWORD, nbobjets:DWORD, structsize:DWORD
mov esi, objetlist
mov ecx, nbobjets
dec ecx
jle fintri
mov edx, structsize
; ecx nb entite - 1
; esi start list sizeof structsize bytes
EVEN
tt0: mov ebp, ecx
mov eax, [esi] ; lit Z
mov edi, esi
add edi, edx
xor ebx, ebx
tt1: cmp [edi], ax
jl plusgrand
cont: add edi, edx
loop tt1
or ebx, ebx
jz short noexchg
; mov eax, [ebx]
; xchg [esi], eax ; permutte
; mov [ebx], eax
mov edi, esi
push edx
shr edx, 2
EVEN
permute: mov eax, [ebx]
xchg [edi], eax ; permutte
mov [ebx], eax
add ebx, 4
add edi, 4
dec dx
jnz permute
pop edx
noexchg: add esi, edx
mov ecx, ebp
loop tt0
fintri: ret
plusgrand: mov ebx, edi
mov eax, [edi]
jmp short cont
SmallSort endp
;*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
;*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
SimpleInitMcga proc uses esi edi ebp ebx
mov ax, 13h
int 10h
ret
SimpleInitMcga endp
;*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
CopyBlockMCGA proc uses esi edi ebx ebp,\
x0:DWORD, y0:DWORD, x1:DWORD, y1:DWORD, src:DWORD,\
xd:DWORD, yd:DWORD, dst:DWORD
mov ebx, y0
mov esi, TabOffLine[ebx*4] ; y0
add esi, src
add esi, x0 ; SI Offset Src
; mov edi, yd
; mov eax, edi
; shl edi, 2 ; *4
; add edi, eax ; *5
; shl edi, 6 ; *320
; add edi, dst
; add edi, xd ; DI Offset Dst
mov edi, dst
mov ebx, y1 ; y0 <=> y1
sub ebx, y0
inc ebx ; BX Delta Y
mov eax, x1
sub eax, x0
inc eax ; AX Delta X
mov edx, 320
sub edx, eax ; DX Delta Screen
mov ebp, 640
sub ebp, eax
Again:
mov ecx, eax
shr ecx, 2
rep movsd
mov ecx, eax
and ecx, 11b
rep movsb
add esi, ebp
add edi, edx
dec ebx
jne short Again
ret
CopyBlockMCGA endp
;*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
;*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
ShadeBox proc uses esi edi ebp ebx,\
x0:DWORD, y0:DWORD, x1:DWORD, y1:DWORD,\
deccoul:DWORD
mov eax, x0
mov ebx, y0
mov ecx, x1
mov edx, y1
;----------------------
cmp eax, ClipXmax
jg Box_End
cmp ecx, ClipXmin
jl Box_End
cmp ebx, ClipYmax
jg Box_End
cmp edx, ClipYmin
jl Box_End
TestLeft:
cmp eax, ClipXmin
jge TestRight
mov eax, ClipXmin
TestRight:
cmp ecx, ClipXmax
jle TestUp
mov ecx, ClipXmax
TestUp:
cmp ebx, ClipYmin
jge TestDown
mov ebx, ClipYmin
TestDown:
cmp edx, ClipYmax
jle OkNoClip
mov edx, ClipYmax
OkNoClip:
;----------------------
mov edi, ebx ; Y0
mov edi, TabOffLine[edi*4]
add edi, Log
add edi, eax ; EDI Offset Src
;----------------------
sub edx, ebx ; Init Delta Y
mov ebx, edx
inc ebx
mov edx, ecx ; Init Delta X
sub edx, eax
inc edx
mov esi, Screen_X
sub esi, edx ; ebp Delta Screen
mov ecx, deccoul
Again: mov ebp, edx
loopx: mov al, byte ptr[edi]
mov ah, al
; and ah, 0F0h
; and al, 00Fh
and ax, 0F00Fh
sub al, cl
jc lesszero
add al, ah
mov byte ptr[edi], al
inc edi
dec ebp
jnz loopx
add edi, esi
dec ebx
jne Again
Box_End:
ret
lesszero: mov al, ah
mov byte ptr[edi], al
inc edi
dec ebp
jnz loopx
add edi, esi
dec ebx
jne Again
ret
ShadeBox endp
;*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
;*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
comment #
DesintegreClip proc uses ebx edi esi ebp
level:DWORD
mov eax, ClipXmin
mov ecx, ClipXmax
mov ebx, ClipYmin
mov edx, ClipYmax
;----------------------
mov edi, ebx ; Y0
mov edi, TabOffLine[edi*4]
add edi, eax ; EDI Offset Src
mov esi, edi
add edi, Log
add esi, Screen
;----------------------
sub edx, ebx ; Init Delta Y
mov ebx, edx
inc ebx
mov edx, ecx ; Init Delta X
sub edx, eax
inc edx
mov eax, Screen_X
sub eax, edx ; ebp Delta Screen
mov [offsety], ecx
Again: mov ebp, edx
loopx:
mov al, byte ptr[esi]
mov ebx, esi
and ebx, 7
and al, byte ptr[ebx] ; plus tard table
mov byte ptr[edi], al
inc edi
inc esi
dec ebp
jnz loopx
add edi, [offsety]
dec ebx
jne Again
ret
DesintegreClip proc
#
;*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
;*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
GetHDFreeSize proc uses ebx
xor eax, eax ;' Cause IMUL
mov ebx, eax ;' Cause IMUL
mov ecx, eax ;' Cause IMUL
mov ah, 36h
mov dl, 0 ;' Current Drive
int 21h ;' Get Free Space
imul ebx
imul ecx ;' Bytes*Sectors*Clusters
ret
GetHDFreeSize endp
;*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
;*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
END

2849
SOURCES/GAMEMENU.C Normal file
View File

File diff suppressed because it is too large Load Diff

45
SOURCES/GAMEMENU.DEF Normal file
View File

@@ -0,0 +1,45 @@
extern void Init3DGame(void);
extern void DrawFire(short ,short ,short ,short ,short );
extern void WaitReleaseSpace(void);
extern void DrawObj3D(short ,short ,short ,short ,short ,short ,unsigned char *);
extern void DrawCadre(short ,short ,short ,short );
extern void DrawComportement(short ,short ,short );
extern void DrawInfoMenu(short ,short );
extern void DrawMenuComportement(short );
extern void MenuComportement(void);
extern void Draw3dObject(short ,short ,short *,short ,short );
extern void DrawOneInventory(short );
extern void DrawListInventory(void);
extern void Inventory(void);
extern void DoFoundObj(short );
extern void ExtInitMcga(void);
extern void ExtInitSvga(void);
extern void TestRestoreModeSVGA(long );
extern void CopyBlockPhysMCGA(long ,long ,long ,long );
extern short PlayerGameList(unsigned char **,unsigned char *);
extern short FindPlayerFile(void);
extern void SaveGame(void);
extern void LoadGame(void);
extern void DrawOneString(short ,short ,unsigned char *,short );
extern void DrawSingleString(short ,short ,unsigned char *);
extern void DrawOneLetter(short ,short ,short );
extern void DrawAllLetters(void);
extern short InputPlayerName(short );
extern short ChoosePlayerName(short );
extern void DrawOneChoice(short ,short ,short ,short ,short );
extern void DrawGameMenu(unsigned short *,short );
extern void SetVolumes(long ,long ,long ,long ,long );
extern short DoGameMenu(unsigned short *);
extern long OptionsMenu(void);
extern void VolumeOptions(void);
extern void SavedGameManagement(void);
extern void AdvancedOptions(void);
extern long MainGameMenu(void);
extern long QuitMenu(void);
extern void GameAskChoice(short );
extern void GameOver(void);
extern void Credits(void);
extern void RessPict(short );
extern void TimerPause(short );
extern void AdelineLogo(void);
extern void MenuDemo(void);

1280
SOURCES/GERELIFE.C Normal file
View File

File diff suppressed because it is too large Load Diff

3
SOURCES/GERELIFE.DEF Normal file
View File

@@ -0,0 +1,3 @@
extern void DoFuncLife(T_OBJET *);
extern short DoTest(void);
extern void DoLife(short );

604
SOURCES/GERETRAK.C Normal file
View File

@@ -0,0 +1,604 @@
#include "c_extern.h"
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
Ûßßßß Ûßßßß ÛßßßÛ Ûßßßß ßßÛßß ÛßßßÛ ÛßßßÛ Ûßßßß Û Üß
ÛÛ ßÛ ÛÛßß ÛÛßÛß ÛÛßß ÛÛ ÛÛßÛß ÛÛßßÛ ÛÛ ÛÛßÜ
ßßßßß ßßßßß ßß ß ßßßßß ßßßßß ßß ßß ß ßß ß ßßßßß ßß ß
*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
WORD BigSampleRepeat = 1 ;
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void DoTrack( WORD numobj )
{
T_OBJET *ptrobj ;
WORD flag ;
UBYTE macro ;
UBYTE string[256] ;
WORD angle ;
LONG dist, y ;
UBYTE *ptrtrack;
UBYTE memooffsettrack;
WORD overflow = 0 ;
UBYTE *ptr ;
UBYTE n, c ;
ptrobj = &ListObjet[numobj] ;
flag = TRUE ;
while( flag )
{
memooffsettrack = ptrobj->OffsetTrack ;
ptrtrack = ptrobj->PtrTrack ;
ptrtrack += ptrobj->OffsetTrack ; /* offset macro en cours */
macro = *ptrtrack++ ;
ptrobj->OffsetTrack++ ;
switch( macro )
{
/*-------------------------------------------------------------------------*/
case TM_SAMPLE:
HQ_3D_MixSample( *(WORD*)ptrtrack, 0x1000, 1,
ptrobj->PosObjX, ptrobj->PosObjY, ptrobj->PosObjZ ) ;
ptrobj->OffsetTrack += 2 ;
break ;
case TM_SAMPLE_RND:
HQ_3D_MixSample( *(WORD*)ptrtrack, 0x800+Rnd(0x800), 1,
ptrobj->PosObjX, ptrobj->PosObjY, ptrobj->PosObjZ ) ;
ptrobj->OffsetTrack += 2 ;
break ;
case TM_SAMPLE_ALWAYS:
HQ_3D_MixSample( *(WORD*)ptrtrack, 0x1000, 0,
ptrobj->PosObjX, ptrobj->PosObjY, ptrobj->PosObjZ ) ;
ptrobj->OffsetTrack += 2 ;
break ;
case TM_SAMPLE_STOP:
HQ_StopOneSample( *(WORD*)ptrtrack ) ;
ptrobj->OffsetTrack += 2 ;
break ;
case TM_REPEAT_SAMPLE:
BigSampleRepeat = *(WORD*)ptrtrack ;
ptrobj->OffsetTrack += 2 ;
break ;
case TM_SIMPLE_SAMPLE:
HQ_MixSample( *(WORD*)ptrtrack, 0x1000, BigSampleRepeat, 128, 128 ) ;
BigSampleRepeat = 1 ;
ptrobj->OffsetTrack += 2 ;
break ;
/*-------------------------------------------------------------------------*/
case TM_PLAY_FLA:
ptr = string ;
n = 0 ;
do { c = *ptrtrack++ ;
*ptr++ = c ;
n++ ;
} while( c != 0 ) ;
ptrobj->OffsetTrack += n ;
SaveTimer() ;
FadeToBlack( PtrPal ) ;
PlayAnimFla( string ) ;
FlagFade = TRUE ;
RestoreTimer() ;
AffScene( TRUE ) ;
break ;
/*-------------------------------------------------------------------------*/
case TM_BODY:
InitBody( *ptrtrack++, numobj ) ;
ptrobj->OffsetTrack ++ ;
break ;
case TM_NO_BODY:
InitBody( NO_BODY, numobj ) ;
break ;
/*-------------------------------------------------------------------------*/
case TM_ANIM:
if( !InitAnim( *ptrtrack++, ANIM_REPEAT, 0, numobj ) )
{
ptrobj->OffsetTrack = memooffsettrack ;
flag = FALSE ;
}
else
{
ptrobj->OffsetTrack++ ;
}
break ;
/*-------------------------------------------------------------------------*/
case TM_WAIT_ANIM:
if( !(ptrobj->WorkFlags & ANIM_END) )
{
ptrobj->OffsetTrack-- ;
flag = FALSE ;
}
else
{
flag = FALSE ;
/* attention si autre utilisation ANIM_END */
/* ptrobj->Flags &= ~ANIM_END ; */
/* sup. ce clear si pb obj avec track pendant
follow ... */
ClearRealAngle( ptrobj ) ;
}
break ;
/*-------------------------------------------------------------------------*/
case TM_WAIT_NB_ANIM:/* LORAN */
ptrobj->OffsetTrack += 2 ;
if( !(ptrobj->WorkFlags & ANIM_END) )
{
flag = FALSE ;
}
else
{
ptrtrack[1]++ ; // nb anim +=
if ( *(ptrtrack+1) == *ptrtrack )
{
*(ptrtrack+1) = 0 ;/* Cpt */
}
else flag = FALSE ;
}
if ( flag == FALSE ) ptrobj->OffsetTrack -= 3 ;
break ;
/*-------------------------------------------------------------------------*/
case TM_WAIT_NB_SECOND:
ptrobj->OffsetTrack += 5 ;
if( *(ULONG*)(ptrtrack+1) == 0 )
{
*(ULONG*)(ptrtrack+1) = TimerRef + ( *ptrtrack * 50 ) ;
}
if ( TimerRef < *(ULONG*)(ptrtrack+1) )
{
ptrobj->OffsetTrack -= 6 ;
flag = FALSE ;
}
else *(ULONG*)(ptrtrack+1) = 0 ;
break ;
/*-------------------------------------------------------------------------*/
case TM_GOTO_POINT:
ptrobj->OffsetTrack++ ;
// if( !(ptrobj->WorkFlags & ANIM_MASTER_ROT) )
{
Value = *ptrtrack ; // index point
X0 = ListBrickTrack[Value].X ;
Y0 = ListBrickTrack[Value].Y ;
Z0 = ListBrickTrack[Value].Z ;
angle = GetAngle( ptrobj->PosObjX,
ptrobj->PosObjZ,
X0, Z0 ) ;
if( ptrobj->Flags & SPRITE_3D )
{
ptrobj->Beta = angle ;
}
else
{
if( Distance < 4000 )
{
InitRealAngleConst( ptrobj->Beta,
angle,
ptrobj->SRot/**Distance/4000*/ ,
&ptrobj->RealAngle ) ;
}
else
{
InitRealAngleConst( ptrobj->Beta,
angle,
ptrobj->SRot,
&ptrobj->RealAngle ) ;
}
}
if( Distance > 500 )
{
ptrobj->OffsetTrack -= 2 ;
flag = FALSE ;
}
}
/* else
{
ptrobj->OffsetTrack -= 2 ;
flag = FALSE ;
}
*/
break ;
/*-------------------------------------------------------------------------*/
case TM_GOTO_POINT_3D:
ptrobj->OffsetTrack++ ;
if( ptrobj->Flags & SPRITE_3D )
{
Value = *ptrtrack ; // index point
X0 = ListBrickTrack[Value].X ;
Y0 = ListBrickTrack[Value].Y ;
Z0 = ListBrickTrack[Value].Z ;
ptrobj->Beta =
GetAngle( ptrobj->PosObjX,
ptrobj->PosObjZ,
X0, Z0 ) ;
ptrobj->FlagAnim = /* alpha */
GetAngle( ptrobj->PosObjY,0,
Y0,Distance ) ;
/* OpenWindow( &DWin, 10,200, 20,5 ) ;
WinText( &DWin, "Dist: ", Distance ) ;
WinText( &DWin, "Flag Y: ", Y0 ) ;
WinText( &DWin, "Obj Y: ", ptrobj->PosObjY ) ;
FlipWindow( &DWin ) ;
*/
if( Distance > 100 )
{
ptrobj->OffsetTrack -= 2 ;
flag = FALSE ;
}
else
{
/* find_me */
ptrobj->PosObjX = X0 ;
ptrobj->PosObjY = Y0 ;
ptrobj->PosObjZ = Z0 ;
}
}
break ;
/*-------------------------------------------------------------------------*/
case TM_GOTO_SYM_POINT:
ptrobj->OffsetTrack++ ;
// if( !(ptrobj->WorkFlags & ANIM_MASTER_ROT) )
{
Value = *ptrtrack ; // index point
X0 = ListBrickTrack[Value].X ;
Y0 = ListBrickTrack[Value].Y ;
Z0 = ListBrickTrack[Value].Z ;
angle = 512 + GetAngle( ptrobj->PosObjX,
ptrobj->PosObjZ,
X0, Z0 ) ;
if( ptrobj->Flags & SPRITE_3D )
{
ptrobj->Beta = angle ;
}
else
{
InitRealAngleConst( ptrobj->Beta,
/* sym */ angle,
ptrobj->SRot,
&ptrobj->RealAngle ) ;
}
if( Distance > 500 )
{
ptrobj->OffsetTrack -= 2 ;
flag = FALSE ;
}
}
/* else
{
ptrobj->OffsetTrack -= 2 ;
flag = FALSE ;
}
*/
break ;
/*-------------------------------------------------------------------------*/
case TM_ANGLE:
ptrobj->OffsetTrack += 2 ;
if( !(ptrobj->Flags & SPRITE_3D) )
{
// if( !(ptrobj->WorkFlags & ANIM_MASTER_ROT) )
{
Value = *(WORD*)ptrtrack ;
if( !ptrobj->RealAngle.TimeValue )
{
InitRealAngleConst( ptrobj->Beta,
Value,
ptrobj->SRot,
&ptrobj->RealAngle ) ;
}
if( ptrobj->Beta != Value )
{
ptrobj->OffsetTrack -= 3 ;
flag = FALSE ;
}
else
{
ClearRealAngle( ptrobj ) ;
}
}
/* else
{
ptrobj->OffsetTrack -= 3 ;
flag = FALSE ;
}
*/
}
break ;
/*-------------------------------------------------------------------------*/
case TM_FACE_TWINKEL:
ptrobj->OffsetTrack+=2 ;
if( !(ptrobj->Flags & SPRITE_3D) )
{
// if( !(ptrobj->WorkFlags & ANIM_MASTER_ROT) )
{
Value = *(WORD*)ptrtrack ;
if( Value == -1 )
{
if( !ptrobj->RealAngle.TimeValue )
{
Value = GetAngle(ptrobj->PosObjX,
ptrobj->PosObjZ,
ListObjet[NUM_PERSO].PosObjX,
ListObjet[NUM_PERSO].PosObjZ );
InitRealAngleConst( ptrobj->Beta,
Value,
ptrobj->SRot,
&ptrobj->RealAngle ) ;
*(WORD*)ptrtrack = Value ;
}
}
if( ptrobj->Beta != Value )
{
ptrobj->OffsetTrack-=3 ;
flag = FALSE ;
}
else
{
ClearRealAngle( ptrobj ) ;
*(WORD*)ptrtrack = -1 ;
}
}
/* else
{
ptrobj->OffsetTrack-=3 ;
flag = FALSE ;
}
*/
}
break ;
/*-------------------------------------------------------------------------*/
case TM_ANGLE_RND:
ptrobj->OffsetTrack += 4 ;
if( !(ptrobj->Flags & SPRITE_3D) )
{
// if( !(ptrobj->WorkFlags & ANIM_MASTER_ROT) )
{
Value = *(WORD*)(ptrtrack+2) ;
if( Value == -1 )
{
if( !ptrobj->RealAngle.TimeValue )
{
if( rand()&1 )
{
Value = *(WORD*)ptrtrack ;
Value = (ptrobj->Beta + 256 + Value/2 - Rnd( Value ))&1023 ;
}
else
{
Value = *(WORD*)ptrtrack ;
Value = (ptrobj->Beta - 256 - Value/2 + Rnd( Value ))&1023 ;
}
InitRealAngleConst( ptrobj->Beta,
Value,
ptrobj->SRot,
&ptrobj->RealAngle ) ;
*(WORD*)(ptrtrack+2) = Value ;
}
}
if( ptrobj->Beta != Value )
{
ptrobj->OffsetTrack -= 5 ;
flag = FALSE ;
}
else
{
ClearRealAngle( ptrobj ) ;
*(WORD*)(ptrtrack+2) = -1 ;
}
}
/* else
{
ptrobj->OffsetTrack -= 5 ;
flag = FALSE ;
}
*/
}
break ;
/*-------------------------------------------------------------------------*/
/* sp‚cifique porte: SPRITE_3D + SPRITE_CLIP */
case TM_OPEN_LEFT:
case TM_OPEN_RIGHT:
case TM_OPEN_UP:
case TM_OPEN_DOWN:
ptrobj->OffsetTrack += 2 ;
if( (ptrobj->Flags & (SPRITE_3D+SPRITE_CLIP)) == SPRITE_3D+SPRITE_CLIP )
{
switch( macro )
{
case TM_OPEN_LEFT:
ptrobj->Beta = 768 ;
break ;
case TM_OPEN_RIGHT:
ptrobj->Beta = 256 ;
break ;
case TM_OPEN_UP:
ptrobj->Beta = 512 ;
break ;
case TM_OPEN_DOWN:
ptrobj->Beta = 0 ;
break ;
}
ptrobj->DoorWidth = *(WORD*)ptrtrack ;
ptrobj->WorkFlags |= AUTO_STOP_DOOR ;
//speed porte
ptrobj->SRot = 1000 ; /* reglage global 8( */
InitRealValue( 0, 1000, 50, &ptrobj->RealAngle ) ;
}
break ;
/*-------------------------------------------------------------------------*/
/* sp‚cifique porte: SPRITE_3D + SPRITE_CLIP */
case TM_CLOSE:
if( (ptrobj->Flags & (SPRITE_3D+SPRITE_CLIP)) == SPRITE_3D+SPRITE_CLIP )
{
ptrobj->WorkFlags |= AUTO_STOP_DOOR ;
ptrobj->DoorWidth = 0 ;
//speed porte
ptrobj->SRot = -1000 ; /* reglage global 8( */
InitRealValue( 0, -1000, 50, &ptrobj->RealAngle ) ;
}
break ;
/*-------------------------------------------------------------------------*/
/* sp‚cifique porte: SPRITE_3D + SPRITE_CLIP */
case TM_WAIT_DOOR:
if( (ptrobj->Flags & (SPRITE_3D+SPRITE_CLIP)) == SPRITE_3D+SPRITE_CLIP )
{
if( ptrobj->SRot != 0 )
{
ptrobj->OffsetTrack-- ;
flag = FALSE ;
}
}
break ;
/*-------------------------------------------------------------------------*/
case TM_BETA:
ptrobj->OffsetTrack += 2 ;
// if( !(ptrobj->WorkFlags & ANIM_MASTER_ROT) )
{
ptrobj->Beta = *(WORD*)ptrtrack ;
if( !(ptrobj->Flags & SPRITE_3D) )
{
ClearRealAngle( ptrobj ) ;
}
}
break ;
/*-------------------------------------------------------------------------*/
case TM_POS_POINT:
ptrobj->OffsetTrack ++ ;
Value = *ptrtrack ; // index point
X0 = ListBrickTrack[Value].X ;
Y0 = ListBrickTrack[Value].Y ;
Z0 = ListBrickTrack[Value].Z ;
if( ptrobj->Flags & SPRITE_3D )
{
ptrobj->SRot = 0 ; //arrete deplacement !!!
}
ptrobj->PosObjX = X0 ;
ptrobj->PosObjY = Y0 ;
ptrobj->PosObjZ = Z0 ;
break ;
/*-------------------------------------------------------------------------*/
case TM_LABEL:
ptrobj->LabelTrack = *ptrtrack ; /* label */
ptrobj->OffsetTrack++ ;
ptrobj->OffsetLabelTrack = ptrobj->OffsetTrack - 2 ;
break ;
/*-------------------------------------------------------------------------*/
case TM_GOTO:
ptrobj->OffsetTrack = *(WORD*)ptrtrack ;
break ;
/*-------------------------------------------------------------------------*/
case TM_LOOP:
/* mettre recherche label */
ptrobj->OffsetTrack = 0 ;
break ;
/*-------------------------------------------------------------------------*/
case TM_SPEED:
ptrobj->OffsetTrack += 2 ;
ptrobj->SRot = *(WORD*)ptrtrack ;
if( ptrobj->Flags & SPRITE_3D )
{ /* voir pour les 2 types ? */
InitRealValue( 0, ptrobj->SRot,
50, &ptrobj->RealAngle ) ;
}
break ;
/*-------------------------------------------------------------------------*/
case TM_BACKGROUND:
ptrobj->OffsetTrack ++ ;
if( *ptrtrack ) /* ON */
{
if( !(ptrobj->Flags & OBJ_BACKGROUND) )
{
ptrobj->Flags |= OBJ_BACKGROUND ;
if( ptrobj->WorkFlags & WAS_DRAWN )
{
FirstTime = TRUE ; /* :-( */
}
}
}
else /* OFF */
{
if( ptrobj->Flags & OBJ_BACKGROUND )
{
ptrobj->Flags &= ~OBJ_BACKGROUND ;
if( ptrobj->WorkFlags & WAS_DRAWN )
{
FirstTime = TRUE ; /* :-( */
}
}
}
break ;
/*-------------------------------------------------------------------------*/
case TM_END:
// ptrobj->Move = NO_MOVE ;
ptrobj->OffsetTrack = -1 ;
flag = FALSE ;
break ;
case TM_STOP:
ptrobj->OffsetTrack = -1 ;
flag = FALSE ;
break ;
}
}
}

1
SOURCES/GERETRAK.DEF Normal file
View File

@@ -0,0 +1 @@
extern void DoTrack(short );

260
SOURCES/GLOBAL.C Normal file
View File

@@ -0,0 +1,260 @@
#include "defines.h"
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
ÛßßßÛ Ûßßßß ÛßßßÛ ÛÛßßß ÛßßßÛ
ÛÛßßß ÛÛßß ÛÛßÛß ßßßßÛ ÛÛ Û
ßß ßßßßß ßß ß ßßßßß ßßßßß
*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
/*--------- divers ---------------------------*/
UBYTE *BufSpeak ;
UBYTE *LbaFont ;
UBYTE *Screen ;
UBYTE PalettePcx[768+500] ;
WORD MyJoy = 0 ;
WORD MyFire = 0 ;
WORD MyKey = 0 ;
UBYTE *PtrPal ;
WORD LastFire = 0 ;
LONG FlagVsync = 0 ;
WORD FlagMCGA = FALSE ;
LONG FlagCredits = FALSE ;
UBYTE String[256] ;
WORD Value ;
LONG SampleVolume, MusicVolume, CDVolume, LineVolume, MasterVolume ;
WORD SamplesEnable = FALSE ;
WORD FlagPalettePcx = FALSE ;
WORD FlagFade = FALSE ;
WORD Bulle = TRUE ;
WORD FlagBlackPal = FALSE ;
#ifdef CDROM
WORD FlaFromCD = TRUE ;
#else
#ifdef MAGOUILLE_FLA_HD
WORD FlaFromCD = TRUE ; // magouille fla sur HD
#else
WORD FlaFromCD = FALSE ;
#endif
#endif
UBYTE PathFla[_MAX_PATH] ;
LONG Version_US = TRUE ;
/*--------- ressources ---------------------------*/
T_HQR_HEADER *HQR_Samples ;
T_HQR_HEADER *HQR_Midi ;
T_HQR_HEADER *InventoryObj ;
UBYTE *BufferShadow ;
/*--------- disk ---------------------------*/
char PleaseWait[60] ;
UBYTE ProgDrive[_MAX_DRIVE] ;
UBYTE ProgDir[_MAX_DIR] ;
ULONG OrgDrive ;
UBYTE OrgDir[_MAX_DIR] ;
/*
UBYTE Drive[_MAX_DRIVE] ;
UBYTE Dir[_MAX_DIR] ;
*/
UBYTE Name[_MAX_FNAME] ;
UBYTE Ext[_MAX_EXT] ;
//UBYTE OrgPathname[_MAX_PATH] ;
//UBYTE ProgramPathname[_MAX_PATH] ;
//UBYTE Pathname[_MAX_PATH] ;
/*--------- script ---------------------------*/
//UBYTE FicName[_MAX_PATH] ;
//UBYTE *PtrFiche ;
//UBYTE *PtrCommand ;
//UBYTE *PtrFicName ;
/*--------- life tools ---------------------------*/
//UBYTE DefPathname[_MAX_PATH] ;
//UBYTE ScePathname[_MAX_PATH] ;
//UBYTE PcxPathname[_MAX_PATH] ;
T_ZONE *ListZone ;
WORD NbZones = 0 ;
T_TRACK *ListBrickTrack ;
WORD NbBrickTrack = 0 ;
/*
T_FLAG ListFlagCube[MAX_FLAGS_CUBE] ;
T_FLAG ListFlagGame[MAX_FLAGS_GAME] ;
*/
UBYTE ListFlagCube[MAX_FLAGS_CUBE] ;
UBYTE ListFlagGame[MAX_FLAGS_GAME] ;
UBYTE ListFlagInventory[MAX_INVENTORY] ;
/*--------- holomap ----------------------------*/
//T_HOLO_OBJ ListHoloObj[MAX_HOLO_OBJ] ;
//WORD NbHoloObj = 0 ;
T_HOLO_POS *ListHoloPos ; // [MAX_HOLO_POS] ;
UBYTE TabHoloPos[MAX_HOLO_POS] ;
//UBYTE *TabHoloPos ;
/*--------- menus -----------------------------*/
WORD GameChoice ;
WORD GameNbChoices ;
WORD GameListChoice[10] ; // max 7 (normally)
/*--------- perso ----------------------------*/
WORD FlagTheEnd = FALSE ;
WORD ActionNormal = FALSE ;
WORD InventoryAction = -1 ;
WORD Weapon = 0 ; // magicball
WORD Comportement = C_NORMAL ;
//WORD AnimRien = -1;
WORD AnimRienNormal, AnimRienSportif, AnimRienAgressif, AnimRienDiscret, AnimRienProtopack ;
UBYTE *PtrFile3dNormal ;
UBYTE *PtrFile3dSportif ;
UBYTE *PtrFile3dAgressif ;
UBYTE *PtrFile3dDiscret ;
UBYTE *PtrFile3dProtopack ;
WORD SceZoom = 1 ; // hard
WORD Shadow = 2 ; // full
WORD ShadowX, ShadowY, ShadowZ ;
UBYTE ShadowCol ;
WORD NumHolomapTraj = -1 ;
WORD NumCube = 0 ; // num cube en cours
WORD NewCube = -1 ; // change cube demand‚
WORD FlagChgCube = 0 ;
WORD NewPosX, NewPosY, NewPosZ ;
WORD SceneStartX, SceneStartY, SceneStartZ ;
WORD CubeStartX, CubeStartY, CubeStartZ ;
WORD GameOverCube = 0 ;
WORD MagicBall = -1 ;
WORD MagicBallType = 1 ;
WORD MagicBallCount = 3 ;
WORD CombatAuto = TRUE ;
WORD MagicLevel = 0 ;
WORD MagicPoint = 0 ;
WORD NbGoldPieces = 0 ;
WORD NbLittleKeys = 0 ;
WORD Chapitre = 0 ;
WORD NbFourLeafClover = 2 ;
WORD NbCloverBox = 2 ;
WORD Island = 0 ;
WORD Fuel = 0 ;
WORD NumPingouin = -1 ;
WORD FlagClimbing = FALSE ;
WORD StartYFalling = 0 ;
T_REAL_VALUE RealFalling ;
WORD StepFalling = 1 ;
WORD FlagWater = FALSE ;
// perso sauvegarde entr‚e cube
//UBYTE SaveGenBody ;
//WORD SaveCube ;
//WORD SaveChapitre ;
WORD SaveComportement = C_NORMAL ;
WORD SaveBeta = 0 ;
//WORD SaveLifePoint ;
//WORD SaveNbGoldPieces ;
//WORD SaveMagicLevel ;
//WORD SaveMagicPoint ;
//WORD SaveNbCloverBox ;
//WORD SaveNbFourLeafClover ;
//UBYTE SaveListFlagGame[MAX_FLAGS_GAME] ;
/*--------- Extra objs ----------------------------*/
T_EXTRA ListExtra[MAX_EXTRAS] ;
//UBYTE *PtrSpriteExtra ;
T_HQR_HEADER *HQRPtrSpriteExtra ;
WORD *PtrZvExtra ;
/*---------------- incrust display ----------------*/
T_INCRUST_DISP ListIncrustDisp[MAX_INCRUST_DISP] ;
/*--------- moteur 3D ----------------------------*/
UBYTE *BufferAnim ;
UBYTE *PtrBufferAnim ;
LONG NbBodys = 0 ;
UBYTE *PtrBody[MAX_BODYS] ;
// T_HQR_HEADER *HQR_Bodys ;
//LONG NbAnims = 0 ;
//UBYTE *PtrAnim[MAX_ANIMS] ;
T_HQR_HEADER *HQR_Anims ;
LONG NbObjets = 0 ;
T_OBJET ListObjet[MAX_OBJETS] ;
T_SORT ListTri[MAX_OBJETS+MAX_EXTRAS] ;
WORD NumObjFollow = NUM_PERSO ;
/*--------- ambiance ----------------------------*/
WORD SampleAmbiance[4] ;
WORD SampleRepeat[4] ;
WORD SampleRnd[4] ;
WORD SamplePlayed = 0 ;
ULONG TimerNextAmbiance = 0 ;
WORD SecondEcart = 30 ;
WORD SecondMin = 10 ;
WORD CubeJingle = 255 ;
UBYTE *PtrXmi = 0 ;
WORD NumXmi = -2 ;
/*--------- brick iso ----------------------------*/
WORD FirstTime = TRUE ;
WORD CameraZone = FALSE ;
WORD FlagAffGrille = TRUE ;

317
SOURCES/GRAPH_A.ASM Normal file
View File

@@ -0,0 +1,317 @@
;----------------------------------------------------------------------------
; Graph_A.ASM 386
; (c) Adeline 1993
;----------------------------------------------------------------------------
.386P
.model SMALL, SYSCALL
;----------------------------------------------------------------------------
.data
;----------------------------------------------------------------------------
include \projet\lib386\lib_svga\svga.ash
comment @
DWORD TabOffset[]
Brick:
- BYTE Delta X
- BYTE Delta Y
Line(Delta Y):
- BYTE NbBlock
Block:
- 00xxxxxxb xxxxxx zeros to jump
- 01xxxxxxb xxxxxx Copy Pix
- 10xxxxxxb xxxxxx Repeat Pix
- BYTE datas[]
@
BufferClip db 512 dup(?)
OffsetBegin dd 0
NbPix dd 0
;----------------------------------------------------------------------------
.code
public NoLanguage AffGraph
public NoLanguage GetDxDyGraph
;----------------------------------------------------------------------------
AffGraph proc uses esi edi ebx ebp,\
numbrick:DWORD, xbrick:DWORD, ybrick:DWORD, \
bankbrick:DWORD
mov eax, numbrick
mov ebx, xbrick
mov ecx, ybrick
mov esi, bankbrick
add esi, [esi+eax*4]; ESI = Begin Data
;-----------------------------------------------
lodsb ; Delta X
movzx edx, al ;
lodsb ; Nb Line ( Delta Y )
movzx eax, al
;----------------------------------------------- Test Clipping
add edx, ebx
add eax, ecx
dec edx
dec eax
cmp ebx, ClipXmin
jl ClippingGraph
cmp ecx, ClipYmin
jl ClippingGraph
cmp edx, ClipXmax
jg ClippingGraph
cmp eax, ClipYmax
jg ClippingGraph
sub edx, ebx
sub eax, ecx
inc edx
inc eax
;----------------------------------------------- Calcul Offset Ecran
mov edi, Log
add edi, TabOffLine[ecx*4]
add edi, ebx
mov bh, al ; BH = NbLine
sub edx, Screen_X ; EDX = Offset Screen
neg edx ; EDX = Screen_X-edx
xor ecx, ecx ; Maz Compteur
;----------------------------------------------- Init NbBlock for this line
NextLine: lodsb ; Nb Block for this line
mov bl, al ; BL = NbBlock
;----------------------------------------------- Manage One Line
SameLine: lodsb ; OpCode
mov cl, al ; Sauve AL
and cl, 00111111b ; AH = Bit 0-5
inc cl ; One More Please...
test al, 11000000b ; AL = Bit 6-7
je JumpZero ; Incrust
test al, 01000000b ; AL = 01b
jne WriteDiffPix ; Pix Differents
;----------------------------------------------- Repeat Same Color
lodsb ; Color to Repeat
rep stosb ; Fill
dec bl ; Nb Block--
jne SameLine ; Continue Same Line
add edi, edx ; EDI += Offset Screen
dec bh ; NbLine--
jne NextLine ; Next Line
ret
;----------------------------------------------- Incrust
JumpZero: add edi, ecx ; Jump Zero (incrust)
dec bl ; Nb Block--
jne SameLine ; Continue Same Line
add edi, edx ; EDI += Offset Screen
dec bh ; NbLine--
jne NextLine ; Next Line
ret
;----------------------------------------------- Copy Diff Pix
WriteDiffPix: rep movsb ; Copy Pix
dec bl ; Nb Block--
jne SameLine ; Continue Same Line
;----------------------------------------------- End of this Line ?
add edi, edx ; EDI += Offset Screen
dec bh ; NbLine--
jne NextLine ; Next Line
ret
;-------------------------------------------------------------------- Clipping
; Graph : ( EBX, ECX ) ( EDX, EAX )
ClippingGraph:
cmp ebx, ClipXmax
jg EndGraph
cmp ecx, ClipYmax
jg EndGraph
cmp edx, ClipXmin
jl EndGraph
cmp eax, ClipYmin
jl EndGraph
cmp ecx, ClipYmin
jge PasHaut
;---------------------- Clipping Haut, Saute ClipYmin-ECX Line(s)
push eax
push ebx
mov ebx, ClipYmin
sub ebx, ecx
mov bh, bl
NextH: lodsb
mov bl, al
SameH: lodsb
test al, 11000000b
je JumpzH
mov ecx, 1
test al, 01000000b
je AquiH
mov ecx, eax
and ecx, 00111111b
inc ecx
AquiH: add esi, ecx
JumpzH: dec bl
jne SameH
dec bh
jne NextH
mov ecx, ClipYmin ; New Y Haut
pop ebx
pop eax
;---------------------- Clipping Bas
PasHaut: cmp eax, ClipYmax
jle PasBas
mov eax, ClipYmax
;---------------------- Clipping Gauche
Pasbas: mov OffsetBegin, 0
cmp ebx, ClipXmin
jge PasGauche
push eax
mov eax, ClipXmin
sub eax, ebx
mov OffsetBegin, eax
pop eax
;---------------------- Clipping Droit
PasGauche: push eax
mov eax, edx
sub eax, ebx
sub eax, OffsetBegin
inc eax
mov NbPix, eax
pop eax
cmp edx, ClipXmax
jle PasDroit
sub edx, ClipXmax
sub NbPix, edx
mov edx, ClipXmax
;----------------------
PasDroit:
mov edi, Log
add edi, TabOffLine[ecx*4]
add edi, ebx
sub eax, ecx
inc al
mov bh, al ; BH NbLine
xor ecx, ecx
mov ebp, edi
;----------------------------------------------
; ESI = DATAS LINE
NextL: lea edi, BufferClip ; EDI = BUFFERCLIP
lodsb
mov bl, al
SameL: lodsb
mov cl, al
and cl, 00111111b
inc cl
test al, 11000000b
je JumpL
test al, 01000000b
jne WriteDiffL
;----------------------
lodsb
rep stosb
jmp nextBlock
;----------------------
JumpL: xor al, al
rep stosb
jmp NextBlock
;----------------------
WriteDiffL: rep movsb
;----------------------
NextBlock: dec bl
jne SameL
;----------------------
push esi ; SAVE ESI
lea esi, BufferClip ; ESI = BUFFERCLIP
mov edi, ebp ; EDI = SCREEN
mov ecx, OffsetBegin
add esi, ecx
add edi, ecx
mov ecx, NbPix
Again: lodsb
or al, al
je Incrust
mov [edi], al
Incrust: inc edi
loop Again
add ebp, 640
pop esi
dec bh
jne NextL
;----------------------
EndGraph: ret
AffGraph endp
;----------------------------------------------------------------------------
;----------------------------------------------------------------------------
GetDxDyGraph proc uses esi edi ,\
num:DWORD, ptdx:DWORD, ptdy:DWORD, bankgraph:DWORD
mov esi, bankgraph
mov eax, num
add esi, [esi+eax*4]
mov edi, ptdx
lodsb
movzx eax, al
stosd
mov edi, ptdy
lodsb
movzx eax, al
stosd
ret
GetDxDyGraph endp
;----------------------------------------------------------------------------
;----------------------------------------------------------------------------
;----------------------------------------------------------------------------
; The
End

735
SOURCES/GRILLE.C Normal file
View File

@@ -0,0 +1,735 @@
#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 ;
}

15
SOURCES/GRILLE.DEF Normal file
View File

@@ -0,0 +1,15 @@
extern long LoadUsedBrick(unsigned long );
extern long InitGrille(unsigned short );
extern void FreeGrille(void);
extern unsigned char *GetAdrColonneMap(long ,long );
extern unsigned char *GetAdrColonneCube(long ,long );
extern void GetShadow(short ,short ,short );
extern unsigned long CreateMaskGph(unsigned char *,unsigned char *);
extern void MixteMapToCube(unsigned char *);
extern void CopyMapToCube(void);
extern void InitBufferCube(void);
extern void DrawOverBrick(short ,short ,short );
extern void DrawOverBrick3(short ,short ,short );
extern void AffBrickBlock(long ,long ,long ,long ,long );
extern void AffGrille(void);
extern void IncrustGrm(short );

4
SOURCES/GRILLE.H Normal file
View File

@@ -0,0 +1,4 @@
#define MAX_SIZE_BRICK_CUBE 361472
#define OFFSET_GRM_HQR 120

565
SOURCES/GRILLE_A.ASM Normal file
View File

@@ -0,0 +1,565 @@
;----------------------------------------------------------------------------
; Grille_A.ASM 386
; (c) Adeline 1993
;----------------------------------------------------------------------------
.386P
.model SMALL, SYSCALL
;----------------------------------------------------------------------------
.data
;----------------------------------------------------------------------------
extrn NoLanguage XMap :DWORD
extrn NoLanguage YMap :DWORD
extrn NoLanguage ZMap :DWORD
extrn NoLanguage XScreen :DWORD
extrn NoLanguage YScreen :DWORD
include \projet\lib386\lib_svga\svga.ash
public NoLanguage CodeJeu
CodeJeu db 0
comment @
UBYTE *BufCube ;
UBYTE *BufMap ;
UBYTE *TabBlock ;
UBYTE *BufferBrick ;
@
extrn NoLanguage BufCube:DWORD
extrn NoLanguage BufMap:DWORD
extrn NoLanguage TabBlock:DWORD
extrn NoLanguage BufferBrick:DWORD
HEADER_BLOCK equ 3
SIZE_CUBE_X equ 64
SIZE_CUBE_Y equ 25
SIZE_CUBE_Z equ 64
SIZE_BRICK_XZ equ 512
SIZE_BRICK_Y equ 256
DEMI_BRICK_XZ equ 256
DEMI_BRICK_Y equ 128
;----------------------------------------------------------------------------
.code
public NoLanguage DecompColonne
public NoLanguage Map2Screen
public NoLanguage MixteColonne
public NoLanguage GetAdrBlock
; public NoLanguage GetColBrick
public NoLanguage WorldColBrick
public NoLanguage WorldColBrickFull
public NoLanguage WorldCodeBrick
;----------------------------------------------------------------------------
;*--------------------------------------------------------------------------*
GetAdrBlock proc ,\
numblock:DWORD
mov ecx, numblock
mov eax, [TabBlock] ; pto = (ULONG*)TabBlock
add eax, [ eax + ecx*4 ] ; TabBlock + pto[numbloc]
ret
GetAdrBlock endp
;*--------------------------------------------------------------------------*
WorldColBrickFull proc xw:DWORD, yw:DWORD, zw:DWORD, ymax:DWORD
;' ptc = BufCube
mov ecx, [BufCube]
;' + (xm*SIZE_CUBE_Y*2)
mov eax, xw
;' xm = (xw+DEMI_BRICK_XZ)/SIZE_BRICK_XZ
add eax, DEMI_BRICK_XZ ; +256
shr eax, 9 ; /512
mov [XMap], eax
;' + ym*2
mov eax, yw
;' ym = yw/SIZE_BRICK_Y
sar eax, 8 ; /256
mov [YMap], eax
;' + zm*3200 (SIZE_CUBE_X*SIZE_CUBE_Y*2)
mov eax, zw
;' zm = (zw+DEMI_BRICK_XZ)/SIZE_BRICK_XZ
add eax, DEMI_BRICK_XZ ; +256
shr eax, 9 ; /512
mov [ZMap], eax
mov eax, [XMap]
or eax, eax ; bound
jl ovfw
cmp eax, 64
jge ovfw
lea eax, [eax*2] ; *2
mov edx, eax ; =
lea eax, [eax*8] ; *16
add edx, eax ; 2 + 16 = 18
lea edx, [edx+eax*2] ; 18 + 32 = 50
add ecx, edx
mov eax, [YMap]
cmp eax, -1
jle col_1
lea ecx, [ecx+eax*2]
mov eax, [ZMap]
or eax, eax ; check bound
jl ovfw
cmp eax, 64
jge ovfw
shl eax, 7 ; *128
mov edx, eax ; = 128
lea eax, [eax*8] ; *1024
add edx, eax ; 128 + 1024 = 1152
lea edx, [edx+eax*2] ; 1152 + 2048 = 3200
add ecx, edx
xor eax, eax
mov al, [ecx]
or al, al
jz nocol
;' if( *ptc != 0 )
;' {
;' block = (*ptc++) - 1 ;
;' adr = GetAdrBlock( block ) ;
;' adr += HEADER_BLOCK ;
;' adr += (*ptc)<<2 ;/* 4 Bytes to Jump */
;' return *adr ;
;' }
mov edx, [TabBlock] ; pto = (ULONG*)TabBlock
add edx, [ edx + eax*4 - 4] ; TabBlock + pto[numblock]
add edx, HEADER_BLOCK
mov al, byte ptr[ecx+1]
lea edx, [edx + eax*4 ]
mov al, [edx]
; check full height
mov edx, ymax
add edx, 255
shr edx, 8 ; / 256 hauteur brick
push ebx
mov ebx, [YMap]
th0: cmp ebx, 24
jae notesth
add ecx, 2
inc ebx
cmp word ptr[ecx], 0
jnz hcol
dec edx
jnz th0
notesth: pop ebx
ret
nocol: ;' return *(ptc+1)
mov al, byte ptr[ecx+1] ; eventuelle col transparente
; check full height
mov edx, ymax
add edx, 255
shr edx, 8 ; / 256 hauteur brick
push ebx
mov ebx, [YMap]
th1: cmp ebx, 24
jae notsth
add ecx, 2
inc ebx
cmp word ptr[ecx], 0
jnz hcol
dec edx
jnz th1
notsth: pop ebx
ret
col_1: ; mov [YMap], 0 ; test y-1
hcol: mov al, 1
ret
ovfw: mov al, 0
ret
WorldColBrickFull endp
;*--------------------------------------------------------------------------*
WorldColBrick proc xw:DWORD, yw:DWORD, zw:DWORD
;' ptc = BufCube
mov ecx, [BufCube]
;' + (xm*SIZE_CUBE_Y*2)
mov eax, xw
;' xm = (xw+DEMI_BRICK_XZ)/SIZE_BRICK_XZ
add eax, DEMI_BRICK_XZ ; +256
shr eax, 9 ; /512
mov [XMap], eax
;' + ym*2
mov eax, yw
;' ym = yw/SIZE_BRICK_Y
sar eax, 8 ; /256
mov [YMap], eax
;' + zm*3200 (SIZE_CUBE_X*SIZE_CUBE_Y*2)
mov eax, zw
;' zm = (zw+DEMI_BRICK_XZ)/SIZE_BRICK_XZ
add eax, DEMI_BRICK_XZ ; +256
shr eax, 9 ; /512
mov [ZMap], eax
mov eax, [XMap]
or eax, eax ; bound
jl ovfw
cmp eax, 64
jge ovfw
lea eax, [eax*2] ; *2
mov edx, eax ; =
lea eax, [eax*8] ; *16
add edx, eax ; 2 + 16 = 18
lea edx, [edx+eax*2] ; 18 + 32 = 50
add ecx, edx
mov eax, [YMap]
cmp eax, -1
jle col_1
or eax, eax ; check bound
jl ovfw
cmp eax, 24
jg ovfw
lea ecx, [ecx+eax*2]
mov eax, [ZMap]
or eax, eax ; check bound
jl ovfw
cmp eax, 64
jge ovfw
shl eax, 7 ; *128
mov edx, eax ; = 128
lea eax, [eax*8] ; *1024
add edx, eax ; 128 + 1024 = 1152
lea edx, [edx+eax*2] ; 1152 + 2048 = 3200
add ecx, edx
xor eax, eax
mov al, [ecx]
or al, al
jz nocol
;' if( *ptc != 0 )
;' {
;' block = (*ptc++) - 1 ;
;' adr = GetAdrBlock( block ) ;
;' adr += HEADER_BLOCK ;
;' adr += (*ptc)<<2 ;/* 4 Bytes to Jump */
;' return *adr ;
;' }
mov edx, [TabBlock] ; pto = (ULONG*)TabBlock
add edx, [ edx + eax*4 - 4] ; TabBlock + pto[numblock]
add edx, HEADER_BLOCK
; essai mov al, byte ptr[edx+1] ; code jeu
; mov [CodeJeu], al
mov al, byte ptr[ecx+1]
lea edx, [edx + eax*4 ]
mov al, [edx]
ret
nocol: ;' return *(ptc+1)
mov al, byte ptr[ecx+1] ; eventuelle col transparente
ret
col_1: ; mov [YMap], 0 ; test col-1
mov al, 1
ret
ovfw: mov al, 0
ret
WorldColBrick endp
;*--------------------------------------------------------------------------*
WorldCodeBrick proc xw:DWORD, yw:DWORD, zw:DWORD
;' ptc = BufCube
mov ecx, [BufCube]
;' + (xm*SIZE_CUBE_Y*2)
mov eax, xw
;' xm = (xw+DEMI_BRICK_XZ)/SIZE_BRICK_XZ
add eax, DEMI_BRICK_XZ ; +256
shr eax, 9 ; /512
mov [XMap], eax
lea eax, [eax*2] ; *2
mov edx, eax ; =
lea eax, [eax*8] ; *16
add edx, eax ; 2 + 16 = 18
lea edx, [edx+eax*2] ; 18 + 32 = 50
add ecx, edx
;' + ym*2
mov eax, yw
cmp eax, -1
jle nocode
;' ym = yw/SIZE_BRICK_Y
shr eax, 8 ; /256
mov [YMap], eax
lea ecx, [ecx+eax*2]
;' + zm*3200 (SIZE_CUBE_X*SIZE_CUBE_Y*2)
mov eax, zw
;' zm = (zw+DEMI_BRICK_XZ)/SIZE_BRICK_XZ
add eax, DEMI_BRICK_XZ ; +256
shr eax, 9 ; /512
mov [ZMap], eax
shl eax, 7 ; *128
mov edx, eax ; = 128
lea eax, [eax*8] ; *1024
add edx, eax ; 128 + 1024 = 1152
lea edx, [edx+eax*2] ; 1152 + 2048 = 3200
add ecx, edx
xor eax, eax
mov al, [ecx]
or al, al
jz nocode
;' if( *ptc != 0 )
;' {
;' block = (*ptc++) - 1 ;
;' adr = GetAdrBlock( block ) ;
;' adr += HEADER_BLOCK ;
;' adr += (*ptc)<<2 ;/* 4 Bytes to Jump */
;' return *adr ;
;' }
mov edx, [TabBlock] ; pto = (ULONG*)TabBlock
add edx, [ edx + eax*4 - 4] ; TabBlock + pto[numblock]
add edx, HEADER_BLOCK
mov al, byte ptr[edx+1]
ret
nocode: ;' return *(ptc+1)
mov al, 0F0h
ret
WorldCodeBrick endp
;----------------------------------------------------------------------------
;----------------------------------------------------------------------------
Map2Screen proc ,\
xm:DWORD, ym:DWORD, zm:DWORD
mov eax, xm
sub eax, zm
mov edx, eax
sal eax, 4 ; *16
lea eax, [eax + edx*8 + 320-8 -23-1]; *24 + XCentre proj
mov XScreen, eax
mov eax, xm
add eax, zm
mov edx, eax
lea eax, [eax*8] ; *8
lea eax, [eax+edx*4]; *12
mov edx, ym
shl edx, 4 ; *16
sub edx, ym ; *15
sub eax, edx
add eax, 240 -25 ; YCentre proj
mov YScreen, eax
ret
Map2Screen endp
;----------------------------------------------------------------------------
DecompColonne proc uses esi edi ebx,\
pts:DWORD, ptd:DWORD
mov esi, pts
mov edi, ptd
xor ecx, ecx
;----------------------------------------------- Get Nb Entity
mov bl, [esi] ; BL = NbEntity
inc esi
;----------------------------------------------- For Every Entity
NewEntity: lodsb ; OpCode
mov cl, al ; CL = AL
and cl, 00111111b ; CL = Repeat
inc cl ; One More ( 1 -> 64 )
test al, 11000000b ; Incrust ?
je JumpZero ; Yes, go...
test al, 01000000b ; Diff Brick ?
jne WriteDiffBrick ; Yes, go...
;----------------------------------------------- Write Same Brick
lodsw ; Get NumBlock & PosBlock
rep stosw ; Fill Brick
dec bl ; Entity--
jne NewEntity ; Again
ret ; End
;----------------------------------------------- Incrust ( Full off Nothing )
JumpZero: xor ax, ax ; NumBlock & PosBlock = 0
rep stosw ; Fill
dec bl ; Entity--
jne NewEntity ; Again
ret ; End
;----------------------------------------------- Write Diff Brick
WriteDiffBrick: rep movsw ; Copy NumBlock & PosBlock
dec bl ; Entity--
jne NewEntity ; Again
ret ; end
DecompColonne endp
;----------------------------------------------------------------------------
MixteColonne proc uses esi edi ebx,\
pts:DWORD, ptd:DWORD
mov esi, pts
mov edi, ptd
xor ecx, ecx
;----------------------------------------------- Get Nb Entity
mov bl, [esi] ; BL = NbEntity
inc esi
;----------------------------------------------- For Every Entity
NewEntity: lodsb ; OpCode
mov cl, al ; CL = AL
and cl, 00111111b ; CL = Repeat
inc cl ; One More ( 1 -> 64 )
test al, 11000000b ; Incrust ?
je JumpZero ; Yes, go...
test al, 01000000b ; Diff Brick ?
jne WriteDiffBrick ; Yes, go...
;----------------------------------------------- Write Same Brick
lodsw ; Get NumBlock & PosBlock
rep stosw ; Fill Brick
dec bl ; Entity--
jne NewEntity ; Again
ret ; End
;----------------------------------------------- Incrust ( Full off Nothing )
JumpZero: lea edi, [edi+ecx*2]; must add ecx WORD!
dec bl ; Entity--
jne NewEntity ; Again
ret ; End
;----------------------------------------------- Write Diff Brick
WriteDiffBrick: rep movsw ; Copy NumBlock & PosBlock
dec bl ; Entity--
jne NewEntity ; Again
ret ; end
MixteColonne endp
;----------------------------------------------------------------------------
; The
End

1075
SOURCES/HOLOMAP.C Normal file
View File

File diff suppressed because it is too large Load Diff

17
SOURCES/HOLOMAP.DEF Normal file
View File

@@ -0,0 +1,17 @@
extern void ComputeCoorMapping(void);
extern void ComputeCoorGlobe(void);
extern int z_sort(short *,short *);
extern void ComputeGlobeProj(void);
extern void DrawHoloMap(short ,short ,short );
extern void DrawListPos(short ,short ,short ,short );
extern long SearchNextArrow(long );
extern long SearchPrevArrow(long );
extern void SetHoloPos(unsigned char );
extern void ClrHoloPos(unsigned char );
extern void DrawTitle(short ,short ,short );
extern void DrawCurseur(void);
extern void InitHoloDatas(void);
extern void HoloMap(void);
extern void DrawHoloObj(unsigned char *,short ,short ,short );
extern short *GiveTrajPtr(long );
extern void HoloTraj(short );

108
SOURCES/INCRUST.C Normal file
View File

@@ -0,0 +1,108 @@
#include "c_extern.h"
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
Û ÛÛÜ Û Ûßßßß ÛßßßÛ Û Û ÛÛßßß ßßÛßß ÛßßßÜ Û ÛÛßßß ÛßßßÛ
ÛÛ ÛÛßÛÛ ÛÛ ÛÛßÛß ÛÛ Û ßßßßÛ ÛÛ ÛÛ Û ÛÛ ßßßßÛ ÛÛßßß
ßß ßß ß ßßßßß ßß ß ßßßßß ßßßßß ßß ßßßßß ßßßß ßß ßßßßß ßß
*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
void InitIncrustDisp( WORD type,
WORD num,
WORD x, WORD y,
WORD info,
WORD move,
WORD timeout )
{
T_INCRUST_DISP *ptrdisp ;
WORD n ;
ptrdisp = ListIncrustDisp ;
for( n=0; n<MAX_INCRUST_DISP; n++, ptrdisp++ )
{
if( ptrdisp->Num == -1 ) /* slot libre */
{
ptrdisp->Num = num ;
ptrdisp->X = x ;
ptrdisp->Y = y ;
ptrdisp->Type = type ;
ptrdisp->Info = info ;
ptrdisp->Move = move ;
ptrdisp->TimerEnd = TimerRef + 50 * timeout ;
return ;
}
}
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
void ChangeIncrustPos( WORD xp0, WORD yp0, WORD xp1, WORD yp1 )
{
T_INCRUST_DISP *ptrdisp ;
WORD n ;
WORD dx, dy ;
dx = xp1 - xp0 ;
dy = yp1 - yp0 ;
ptrdisp = ListIncrustDisp ;
for( n=0; n<MAX_INCRUST_DISP; n++, ptrdisp++ )
{
if( ptrdisp->Type == INCRUST_NUM )
{
ptrdisp->X += dx ;
ptrdisp->Y += dy ;
}
}
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
WORD LastNumBulle = -1 ;
WORD SpriteBulle = 91 ;
void DrawBulle( WORD numobj )
{
LONG dx, dy ;
ProjettePoint( ListObjet[numobj].PosObjX - WorldXCube,
ListObjet[numobj].PosObjY + ListObjet[numobj].Ymax - WorldYCube,
ListObjet[numobj].PosObjZ - WorldZCube ) ;
if( LastNumBulle != numobj )
{
SpriteBulle ^= 1 ;
LastNumBulle = numobj ;
}
GetDxDyGraph( 0, &dx, &dy, HQR_Get(HQRPtrSpriteExtra, SpriteBulle ) ) ;
if( SpriteBulle == 90 ) ScreenXmin = Xp + 10 ;
else ScreenXmin = Xp - 10 - dx ;
ScreenYmin = Yp - 20 ;
ScreenXmax = ScreenXmin + dx -1 ;
ScreenYmax = ScreenYmin + dy -1 ;
SetClip( ScreenXmin, ScreenYmin, ScreenXmax, ScreenYmax ) ;
AffGraph( 0, ScreenXmin, ScreenYmin, HQR_Get(HQRPtrSpriteExtra, SpriteBulle) ) ;
if( ClipXmin <= ClipXmax
AND ClipYmin <= ClipYmax )
{
CopyBlockPhys( ClipXmin, ClipYmin, ClipXmax, ClipYmax ) ;
}
UnSetClip() ;
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/

3
SOURCES/INCRUST.DEF Normal file
View File

@@ -0,0 +1,3 @@
extern void InitIncrustDisp(short ,short ,short ,short ,short ,short ,short );
extern void ChangeIncrustPos(short ,short ,short ,short );
extern void DrawBulle(short );

10
SOURCES/M.BAT Normal file
View File

@@ -0,0 +1,10 @@
copy f:\projet\lba\tools\perso\common.h
copy f:\projet\lba\tools\perso\grille.h
copy f:\projet\lba\tools\perso\message.c
copy f:\compil\watcom10\lib386\qsort.obj
rem copy f:\compil\watcom10\lib386\hrder386.obj
del version.obj
call watcom9
wmake WATCOM9=yes
call watcom10

66
SOURCES/MAKEFILE Normal file
View File

@@ -0,0 +1,66 @@
# name the compiler
!ifdef %HOME
!ifeq WATCOM9 yes
CC = c:\compil\watcom\bin\wcc386p
CL = c:\compil\watcom\binb\Wcl386
WL = c:\compil\watcom\binb\wlib
!else
CC = c:\compil\watcom10\binb\wcc386
CL = c:\compil\watcom10\binb\Wcl386
WL = c:\compil\watcom10\binb\wlib
!endif
!else
!ifeq WATCOM9 yes
CC = f:\compil\watcom\bin\wcc386p
CL = f:\compil\watcom\binb\Wcl386
WL = f:\compil\watcom\binb\wlib
!else
CC = f:\compil\watcom10\binb\wcc386
CL = f:\compil\watcom10\binb\Wcl386
WL = f:\compil\watcom10\binb\wlib
!endif
!endif
ASM = ml
!ifeq WATCOM9 yes
CFLAGS = /oeaxt /zp2 /4s /zq /v /s /DWATCOM9
# /d2
# /DTRACE
!else
CFLAGS = /oeaxt /zp2 /5s /zq /s
!endif
AFLAGS = /Cx /Zm /c /W0 /Sa /DNoLanguage=SYSCALL /Djumps=;
LFLAGS = /l=dos4g /x /zq /4s /k7000
# /d2
# /"OPTION SYMFILE=LBA.SYM OPTION MAP=LBA.MAP"
.SILENT
OBJETS1 = version.obj perso.obj object.obj global.obj
OBJETS2 = flipbox.obj diskfunc.obj fiche.obj extra.obj incrust.obj
OBJETS3 = grille.obj grille_a.obj func.obj cpymask.obj
OBJETS4 = Message.obj ambiance.obj Balance.obj gamemenu.obj fire.obj
OBJETS5 = geretrak.obj gerelife.obj
OBJETS6 = HoloMap.obj playfla.obj adfli_a.obj mcga.obj
EXE = LBA0
$(EXE).exe: $(OBJETS1) $(OBJETS2) $(OBJETS3) $(OBJETS4) $(OBJETS5) $(OBJETS6)
if exist tempo.obs del tempo.obs
if exist tempo.obj del tempo.obj
copy /B *.obj tempo.obs
ren tempo.obs tempo.obj
$(CL) $(LFLAGS) /fe=$(EXE).exe tempo.obj
del tempo.obj
prntitre M "$(EXE) OK"
# wstrip $(EXE)
copy $(EXE).exe \projet\lba\game
.c.obj :
PRNTITRE M "$*.C"
$(CC) $^& $(CFLAGS)
.asm.obj :
PRNTITRE M "$*.ASM"
$(ASM) $(AFLAGS) $^&.ASM

315
SOURCES/MALLOC.C Normal file
View File

@@ -0,0 +1,315 @@
/*
MALLOC (c) Adeline 1993
Functions:
- Malloc
- Free
- Mshrink
*/
#include <i86.h>
#include <dos.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <malloc.h>
#include "h:\projet\lib386\lib_sys\adeline.h"
#include "h:\projet\lib386\lib_sys\lib_sys.h"
struct meminfo {
unsigned LargestBlockAvail;
unsigned MaxUnlockedPage;
unsigned LargestLockablePage;
unsigned LinAddrSpace;
unsigned NumFreePagesAvail;
unsigned NumPhysicalPagesFree;
unsigned TotalPhysicalPages;
unsigned FreeLinAddrSpace;
unsigned SizeOfPageFile;
unsigned Reserved[3];
} MemInfo;
#define DPMI_INT 0x31
// #define DEBUG_MALLOC 1
#ifdef DEBUG_MALLOC
LONG ModeTraceMalloc = FALSE ;
#endif
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
/* Special, Allocate Memory Under First Meg */
void *DosMalloc( LONG size, ULONG *handle )
{
union REGS r ;
ULONG strat ;
ULONG addr ;
//#ifdef jhjkhjkhjlk
r.x.eax = 0x5800 ;
int386( 0x21, &r, &r ) ;
strat = r.x.eax ;/* Save DOS alloc strategie */
r.x.eax = 0x5801 ;
r.x.ebx = 1 ;/* Low mem, best fit */
int386( 0x21, &r, &r ) ;/* Set alloc strategie */
//#endif
r.x.eax = 0x0100 ;/* Function allocate Dos Memory */
if (size == -1)
r.x.ebx = -1 ;/*Number off Paragraphs Requested */
else
r.x.ebx =(size+15)>>4;/*Number off Paragraphs Requested */
int386( 0x31, &r, &r ) ;/* Invoke DPMI */
addr = 0 ;
if (size == -1)
{
if( r.x.cflag )
addr = (r.x.ebx & 0xFFFF) << 4 ;
}
else
{
if( !r.x.cflag )
{
if (handle) *handle = r.x.edx & 0xFFFF;/* DPMI selector*/
addr = (r.x.eax & 0xFFFF) << 4;/* Ok, Take this! */
}
}
//#ifdef hjhkjhlhjk
r.x.eax = 0x5801 ;
r.x.ebx = strat ;/* Odl startegie */
int386( 0x21, &r, &r ) ;/* Set alloc strategie */
//#endif
return((void *)addr) ;
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
/* Special, Free Allocated Memory Under First Meg */
void DosFree( ULONG handle )
{
union REGS r ;
r.x.eax = 0x0101 ;/* Function allocate Dos Memory */
r.x.edx = handle ;/* DPMI Selector */
int386( 0x31, &r, &r ) ;/* Invoke DPMI */
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
#ifdef DEBUG_MALLOC
LONG mymalloc( LONG lenalloc, void **memptr )
{
union REGS regs ;
struct SREGS sregs ;
UBYTE *ptr ;
lenalloc+=16;
regs.x.eax = 0x00000501 ;
regs.x.ebx = lenalloc>>16 ;
regs.x.ecx = lenalloc & 0xFFFF ;
sregs.es = 0 ;
sregs.ds = 0 ;
sregs.fs = 0 ;
sregs.gs = 0 ;
int386x( DPMI_INT, &regs, &regs, &sregs ) ;
if( regs.x.cflag )
{
*memptr = NULL ;
return regs.x.eax ;
}
ptr=(UBYTE *)((regs.x.ebx<<16) | (regs.x.ecx & 0xFFFF));
*(WORD*)(ptr+0)=(WORD)regs.x.esi ;
*(WORD*)(ptr+2)=(WORD)regs.x.edi ;
*memptr=(void*)(ptr+16) ;
return 0 ;
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
LONG myfree( void *ptr )
{
union REGS regs ;
struct SREGS sregs ;
UBYTE *ptrh ;
ptrh = ptr ;
ptrh -= 16 ;
regs.x.esi = *(WORD*)(ptrh+0) ;
regs.x.edi = *(WORD*)(ptrh+2) ;
regs.x.eax = 0x00000502 ;
sregs.es = 0 ;
sregs.ds = 0 ;
sregs.fs = 0 ;
sregs.gs = 0 ;
int386x( DPMI_INT, &regs, &regs, &sregs ) ;
return regs.x.cflag ? regs.x.eax : 0 ;
}
#endif
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
void *SmartMalloc( LONG lenalloc )
{
union REGS r ;
ULONG strat ;
ULONG addr ;
r.x.eax = 0x5800 ;
int386( 0x21, &r, &r ) ;
strat = r.x.eax ;/* Save DOS alloc strategie */
r.x.eax = 0x5801 ;
r.x.ebx = 0x81 ;/* UMB first then Low mem, best fit*/
int386( 0x21, &r, &r ) ;/* Set alloc strategie */
r.x.eax = 0x0100 ;/* Function allocate Dos Memory */
r.x.ebx =(lenalloc+15)>>4;/*Number off Paragraphs Requested */
int386( 0x31, &r, &r ) ;/* Invoke DPMI */
if( !r.x.cflag )
addr = (r.x.eax & 0xFFFF) << 4;/* Ok, Take this! */
else
addr = (ULONG)malloc( lenalloc );
r.x.eax = 0x5801 ;
r.x.ebx = strat ;/* Odl startegie */
int386( 0x21, &r, &r ) ;/* Set alloc strategie */
return((void *)addr) ;
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
void *Malloc( LONG lenalloc )
{
union REGS regs ;
struct SREGS sregs ;
void *ptr ;
FILE *fh ;
ULONG size, error ;
if ( lenalloc != -1 )
{
#ifdef DEBUG_MALLOC
if( ModeTraceMalloc )
{
fh = fopen( "c:\\malloc.lst","a+t" ) ;
if( fh != NULL )
{
regs.x.eax = 0x00000500 ;
sregs.es = FP_SEG( &MemInfo ) ;
sregs.ds = 0 ;
regs.x.edi = FP_OFF( &MemInfo ) ;
int386x( DPMI_INT, &regs, &regs, &sregs ) ;
size = MemInfo.LargestBlockAvail ;
fprintf( fh, "Mem: %d\n", size ) ;
}
error = mymalloc(lenalloc, &ptr) ;
// ptr = malloc( lenalloc ) ;
if( fh != NULL )
{
fprintf( fh, "Malloc: %d bytes at %X to %X\n", lenalloc, ptr, (LONG)ptr+lenalloc ) ;
if( error )
fprintf( fh, "Error: %X\n", error ) ;
regs.x.eax = 0x00000500 ;
sregs.es = FP_SEG( &MemInfo ) ;
sregs.ds = 0 ;
regs.x.edi = FP_OFF( &MemInfo ) ;
int386x( DPMI_INT, &regs, &regs, &sregs ) ;
size = MemInfo.LargestBlockAvail ;
fprintf( fh, "Mem: %d\n", size ) ;
fclose( fh ) ;
}
}
else
#endif
{
ptr = malloc( lenalloc ) ;
}
return( ptr ) ;
}
regs.x.eax = 0x00000500 ;
sregs.es = FP_SEG( &MemInfo ) ;
sregs.ds = 0 ;
regs.x.edi = FP_OFF( &MemInfo ) ;
int386x( DPMI_INT, &regs, &regs, &sregs ) ;
return( (void *)MemInfo.LargestBlockAvail ) ;
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
void Free( void *buffer )
{
union REGS regs ;
struct SREGS sregs ;
void *ptr ;
FILE *fh ;
ULONG size, error ;
#ifdef DEBUG_MALLOC
if( ModeTraceMalloc )
{
fh = fopen( "c:\\malloc.lst","a+t" ) ;
if( fh != NULL )
{
regs.x.eax = 0x00000500 ;
sregs.es = FP_SEG( &MemInfo ) ;
sregs.ds = 0 ;
regs.x.edi = FP_OFF( &MemInfo ) ;
int386x( DPMI_INT, &regs, &regs, &sregs ) ;
size = MemInfo.LargestBlockAvail ;
fprintf( fh, "Mem: %d\n", size ) ;
}
error = myfree( buffer ) ;
// free( buffer ) ;
if( fh != NULL )
{
fprintf( fh, "Free: %X\n", buffer ) ;
if( error )
fprintf( fh, "Error: %X\n", error ) ;
regs.x.eax = 0x00000500 ;
sregs.es = FP_SEG( &MemInfo ) ;
sregs.ds = 0 ;
regs.x.edi = FP_OFF( &MemInfo ) ;
int386x( DPMI_INT, &regs, &regs, &sregs ) ;
size = MemInfo.LargestBlockAvail ;
fprintf( fh, "Mem: %d\n", size ) ;
fclose( fh ) ;
}
}
else
#endif
{
free( buffer ) ;
}
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
void *Mshrink( void *buffer, ULONG taille )
{
return _expand( buffer, (size_t)taille ) ;
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/

6
SOURCES/MALLOC.DEF Normal file
View File

@@ -0,0 +1,6 @@
extern void *DosMalloc(long ,unsigned long *);
extern void DosFree(unsigned long );
extern void *SmartMalloc(long );
extern void *Malloc(long );
extern void Free(void *);
extern void *Mshrink(void *,unsigned long );

600
SOURCES/MASK_A.ASM Normal file
View File

@@ -0,0 +1,600 @@
;----------------------------------------------------------------------------
; Mask_A.ASM 386
; (c) Adeline 1993
;----------------------------------------------------------------------------
.386P
.model SMALL, SYSCALL
;----------------------------------------------------------------------------
.data
;----------------------------------------------------------------------------
include \projet\lib386\lib_svga\svga.ash
comment @
DWORD TabOffset[]
Brick:
- BYTE Delta X
- BYTE Delta Y
Line(Delta Y):
- BYTE NbBlock
Block 0: Nb Zero to Jump
Block 1: Nb Zero to Write
Block 2: Nb Zero to Jump
etc...
@
BufferClip db 512 dup(?)
OffsetBegin dd 0
NbPix dd 0
extrn NoLanguage Screen:DWORD
;----------------------------------------------------------------------------
.code
public NoLanguage CopyMask
public NoLanguage AffMask
public NoLanguage GetDxDyMask
;----------------------------------------------------------------------------
CopyMask proc uses esi edi ebx ebp,\
nummask:DWORD, xmask:DWORD, ymask:DWORD, \
bankmask:DWORD, ptsrc:DWORD
mov eax, nummask
mov ebx, xmask
mov ecx, ymask
mov esi, bankmask
add esi, [esi+eax*4]; ESI = Begin Data
movzx eax, byte ptr[esi+2] ; Hot X
add ebx, eax
movzx eax, byte ptr[esi+3] ; Hot Y
add ecx, eax
;-----------------------------------------------
lodsb ; Delta X
movzx edx, al ;
lodsb ; Nb Line ( Delta Y )
movzx eax, al
add esi, 2 ; Jump Hot X & Hot Y
;----------------------------------------------- Test Clipping
add edx, ebx
add eax, ecx
dec edx
dec eax
cmp ebx, ClipXmin
jl ClippingMask
cmp ecx, ClipYmin
jl ClippingMask
cmp edx, ClipXmax
jg ClippingMask
cmp eax, ClipYmax
jg ClippingMask
sub edx, ebx
sub eax, ecx
inc edx
inc eax
;----------------------------------------------- Calcul Offset Ecran
add ebx, TabOffLine[ecx*4]
mov edi, Log
add edi, ebx
mov ebp, ptsrc
add ebp, ebx
mov bh, al ; BH = NbLine
sub edx, Screen_X ; EDX = Offset Screen
neg edx ; EDX = Screen_X-edx
xor ecx, ecx ; Maz Compteur
mov eax, ecx
;----------------------------------------------- Init NbBlock for this line
NextLine: lodsb ; Nb Block for this line
mov bl, al ; BL = NbBlock
;----------------------------------------------- Manage One Line
SameLine: lodsb ; Nb Zero to Jump
add edi, eax ; Incrust on Log
add ebp, eax ; And on PtSrc
dec bl
je EndBlock
lodsb ; Nb Zero to Write
mov cl, al
; xor al, al
; rep stosb
xchg esi, ebp
mov al, cl
shr cl, 2
rep movsd ; Write Datas From PtSrc
mov cl, al
and cl, 11b
rep movsb
xchg esi, ebp
dec bl ; Nb Block--
jne SameLine ; Continue Same Line
EndBlock:
add edi, edx ; EDI += Offset Screen
add ebp, edx
dec bh ; NbLine--
jne NextLine ; Next Line
;----------------------------------------------- Incrust
ret
;-------------------------------------------------------------------- Clipping
; Graph : ( EBX, ECX ) ( EDX, EAX )
ClippingMask:
cmp ebx, ClipXmax
jg EndMask
cmp ecx, ClipYmax
jg EndMask
cmp edx, ClipXmin
jl EndMask
cmp eax, ClipYmin
jl EndMask
cmp ecx, ClipYmin
jge PasHaut
;---------------------- Clipping Haut, Saute ClipYmin-ECX Line(s)
sub ecx, ClipYMin
neg ecx
mov ebp, eax
xor eax, eax
NextH: lodsb
add esi, eax
loop NextH
mov ecx, ClipYMin
mov eax, ebp
;---------------------- Clipping Bas
PasHaut: cmp eax, ClipYmax
jle PasBas
mov eax, ClipYmax
;---------------------- Clipping Gauche
Pasbas: mov OffsetBegin, 0
cmp ebx, ClipXmin
jge PasGauche
mov ebp, ClipXmin
sub ebp, ebx
mov OffsetBegin, ebp
;---------------------- Clipping Droit
PasGauche:
mov ebp, edx
sub ebp, ebx
sub ebp, OffsetBegin
inc ebp
mov NbPix, ebp
cmp edx, ClipXmax
jle PasDroit
sub edx, ClipXmax
sub NbPix, edx
mov edx, ClipXmax
;----------------------
PasDroit: ; ESI debut data Y ok pas X
; EBX not clipped X0
; ECX good Y0
; EAX clipped Y1
; NbPix real X nb pix
; OffsetBegin start X ( !!!!! < 128 )
mov ebp, esi
mov edi, TabOffLine[ecx*4]
add edi, ebx
mov esi, edi ; good Y offset screen
add edi, Log
add esi, Screen ; Screen
mov edx, eax
sub edx, ecx
inc edx
xor ecx, ecx
l1: push esi
push edi
mov bl, byte ptr[ebp] ; nb blocs
inc ebp
mov bh, byte ptr[NbPix] ; nb point … copier
mov ecx, [OffsetBegin] ; start x
mov ah, cl ; nb pix count
add edi, ecx ; new pos screen
add esi, ecx
l0: mov al, byte ptr[ebp] ; nb pix to jump
inc ebp
dec bl
sub ah, al
jz okdraw ; tombe pile
jc rptj ; reste pix to jump
or bl, bl
jz aplus
mov al, byte ptr[ebp] ; nb copy point
inc ebp
dec bl
sub ah, al
jz okjump
jc rgtc ; reste graph to copy
or bl, bl ; jmp l0
jnz l0
jmp aplus
rptj: neg ah ; ah nb pix to jump
mov cl, ah
sub bh, ah ; reste … ecrire
jle aplus
add edi, ecx
add esi, ecx
jmp okdraw
rgtc: neg ah ; al nb pix to copy
mov cl, ah
sub bh, ah ; reste … ecrire
jc cpt ; copy pas tout
rep movsb ; copy
jz aplus ; tombe pile
jmp okjump
cpt: add cl, bh
rep movsb
jmp aplus
EVEN
okjump: mov cl, byte ptr[ebp] ; al nb pix to jump
inc ebp
dec bl
jz aplus
sub bh, cl ; reste … ecrire
jle aplus ; fini
add edi, ecx
add esi, ecx
okdraw: mov cl, byte ptr[ebp] ; nb pix to copy
inc ebp
dec bl
sub bh, cl ; reste … ecrire
jc cpt ; copy pas tout
rep movsb ; copy
jz aplus ; tombe pile
or bl,bl ; nb bloc--
jz aplus
jmp short okjump
aplus: ; ligne finie
movzx eax, bl
add ebp, eax
pop edi
pop esi
add edi, 640
add esi, 640
dec dl ; nb lig--
jnz l1
comment #
add ebx, TabOffLine[ecx*4]
mov edi, Log
add edi, ebx
sub eax, ecx
inc al
mov bh, al ; BH NbLine
xor ecx, ecx
mov ebp, edi
;----------------------------------------------
; ESI = DATAS LINE
NextL: lea edi, BufferClip ; EDI = BUFFERCLIP
lodsb ; NbBlock
mov bl, al
SameL: lodsb
mov cl, al
mov al, 1
rep stosb
dec bl
je EndLine
lodsb
mov cl, al
xor al, al
rep stosb
dec bl
jne SameL
;----------------------
EndLine: push esi ; SAVE ESI
lea esi, BufferClip ; ESI = BUFFERCLIP
mov edi, ebp ; EDI = SCREEN
mov ecx, OffsetBegin
add esi, ecx
add edi, ecx
mov ecx, NbPix
;----------------------
Again:
lodsb
or al, al
jne Incrust
mov [edi], al
Incrust: inc edi
loop Again
add ebp, 640
pop esi
dec bh
jne NextL
;----------------------
#
EndMask: ret
CopyMask endp
;----------------------------------------------------------------------------
AffMask proc uses esi edi ebx ebp,\
nummask:DWORD, xmask:DWORD, ymask:DWORD, \
bankmask:DWORD
mov eax, nummask
mov ebx, xmask
mov ecx, ymask
mov esi, bankmask
add esi, [esi+eax*4]; ESI = Begin Data
;-----------------------------------------------
lodsb ; Delta X
movzx edx, al ;
lodsb ; Nb Line ( Delta Y )
movzx eax, al
;----------------------------------------------- Test Clipping
add edx, ebx
add eax, ecx
dec edx
dec eax
cmp ebx, ClipXmin
jl ClippingMask
cmp ecx, ClipYmin
jl ClippingMask
cmp edx, ClipXmax
jg ClippingMask
cmp eax, ClipYmax
jg ClippingMask
sub edx, ebx
sub eax, ecx
inc edx
inc eax
;----------------------------------------------- Calcul Offset Ecran
mov edi, Log
add edi, TabOffLine[ecx*4]
add edi, ebx
mov bh, al ; BH = NbLine
sub edx, Screen_X ; EDX = Offset Screen
neg edx ; EDX = Screen_X-edx
xor ecx, ecx ; Maz Compteur
;----------------------------------------------- Init NbBlock for this line
NextLine: lodsb ; Nb Block for this line
mov bl, al ; BL = NbBlock
;----------------------------------------------- Manage One Line
SameLine: lodsb ; Nb Zero to Jump
add edi, eax ; Incrust
dec bl
je EndBlock
lodsb ; Nb Zero to Write
mov cl, al
xor al, al
rep stosb ; Write Zero
dec bl ; Nb Block--
jne SameLine ; Continue Same Line
EndBlock:
add edi, edx ; EDI += Offset Screen
dec bh ; NbLine--
jne NextLine ; Next Line
;----------------------------------------------- Incrust
ret
;-------------------------------------------------------------------- Clipping
; Graph : ( EBX, ECX ) ( EDX, EAX )
ClippingMask:
cmp ebx, ClipXmax
jg EndMask
cmp ecx, ClipYmax
jg EndMask
cmp edx, ClipXmin
jl EndMask
cmp eax, ClipYmin
jl EndMask
cmp ecx, ClipYmin
jge PasHaut
;---------------------- Clipping Haut, Saute ClipYmin-ECX Line(s)
push eax
push ebx
mov ebx, ClipYmin
sub ebx, ecx
;----------------------
xor eax, eax
NextH: lodsb ; NbBlock
add esi, eax ; Jump Data
dec bl
jne NextH
mov ecx, ClipYmin ; New Y Haut
pop ebx
pop eax
;---------------------- Clipping Bas
PasHaut: cmp eax, ClipYmax
jle PasBas
mov eax, ClipYmax
;---------------------- Clipping Gauche
Pasbas: mov OffsetBegin, 0
cmp ebx, ClipXmin
jge PasGauche
push eax
mov eax, ClipXmin
sub eax, ebx
mov OffsetBegin, eax
pop eax
;---------------------- Clipping Droit
PasGauche: push eax
mov eax, edx
sub eax, ebx
sub eax, OffsetBegin
inc eax
mov NbPix, eax
pop eax
cmp edx, ClipXmax
jle PasDroit
sub edx, ClipXmax
sub NbPix, edx
mov edx, ClipXmax
;----------------------
PasDroit:
mov edi, Log
add edi, TabOffLine[ecx*4]
add edi, ebx
sub eax, ecx
inc al
mov bh, al ; BH NbLine
xor ecx, ecx
mov ebp, edi
;----------------------------------------------
; ESI = DATAS LINE
NextL: lea edi, BufferClip ; EDI = BUFFERCLIP
lodsb ; NbBlock
mov bl, al
SameL: lodsb
mov cl, al
mov al, 1
rep stosb
dec bl
je EndLine
lodsb
mov cl, al
xor al, al
rep stosb
dec bl
jne SameL
;----------------------
EndLine: push esi ; SAVE ESI
lea esi, BufferClip ; ESI = BUFFERCLIP
mov edi, ebp ; EDI = SCREEN
mov ecx, OffsetBegin
add esi, ecx
add edi, ecx
mov ecx, NbPix
Again: lodsb
or al, al
jne Incrust
mov [edi], al
Incrust: inc edi
loop Again
add ebp, 640
pop esi
dec bh
jne NextL
;----------------------
EndMask: ret
AffMask endp
;----------------------------------------------------------------------------
GetDxDyMask proc uses esi edi ebx,\
num:DWORD, ptdx:DWORD, ptdy:DWORD, bankmask:DWORD
mov esi, bankmask
mov eax, num
add esi, [esi+eax*4]
mov edi, ptdx
lodsb
movzx eax, al
stosd
mov edi, ptdy
lodsb
movzx eax, al
stosd
ret
GetDxDyMask endp
;----------------------------------------------------------------------------
; The
End

53
SOURCES/MCGA.ASM Normal file
View File

@@ -0,0 +1,53 @@
;----------------------------------------------------------------------------
;
;' MCGA.ASM 386
;' (c) Adeline 1994
;
;----------------------------------------------------------------------------
.386P
.model SMALL, SYSCALL
JUMPS
;----------------------------------------------------------------------------
.data
;----------------------------------------------------------------------------
include \projet\lib386\lib_svga\svga.ash
;----------------------------------------------------------------------------
public NoLanguage Mcga_Cls
public NoLanguage Mcga_Flip
.code
;//--------------------------------------------------------------------------
Mcga_Cls proc uses edi
xor eax, eax
mov edi, Log
mov ecx, 64000/4
rep stosd
ret
Mcga_Cls endp
;//--------------------------------------------------------------------------
Mcga_Flip proc uses esi edi
mov esi, Log
mov edi, Phys
mov ecx, 64000/4
rep movsd
ret
Mcga_Flip endp
;----------------------------------------------------------------------------
; The
End

1562
SOURCES/MESSAGE.C Normal file
View File

File diff suppressed because it is too large Load Diff

27
SOURCES/MESSAGE.DEF Normal file
View File

@@ -0,0 +1,27 @@
extern void TimeBar(unsigned long ,unsigned long );
extern void InitLanguage(void);
extern long FindText(long );
extern void InitDial(long );
extern void ClearDial(void);
extern void GetNextWord(char *,char *);
extern void PushCar(long ,long ,long );
extern void AffOneCar(long ,long ,long ,long );
extern void AffAllCar(void);
extern void CoulDial(long ,long ,long );
extern void TestCoulDial(short );
extern long GetText(long );
extern void AffFleche(void);
extern void InitDialWindow(void);
extern void SecondInitDialWindow(void);
extern void NormalWinDial(void);
extern void BigWinDial(void);
extern void CommonOpenDial(long );
extern void OpenDial(long );
extern void OpenDialNoWindow(long );
extern void GetNextLine(void);
extern void InitEndPage(void);
extern long NextDialCar(void);
extern void CloseDial(void);
extern void Dial(long );
extern void MyDial(short );
extern char *GetMultiText(long ,char *);

50
SOURCES/MIXER.C Normal file
View File

@@ -0,0 +1,50 @@
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*
SAMP.C 386
(c) Adeline 1993
*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
#include "\projet\lib386\lib_sys\adeline.h"
#include "\projet\lib386\lib_sys\lib_sys.h"
#include "\projet\lib386\lib_mix\lib_mix.h"
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <i86.h>
char *MixerError = "Error MixerDriver:";
extern void *Mixer_listfcts;
extern LONG Mixer_Driver_Enable;
/*-------------------------------------------------------------------------*/
LONG MixerInitDLL(char *driverpathname)
{
char *dll, *drvr;
//
// Load driver file
//
dll = FILE_read( driverpathname, NULL);
if (dll==NULL)
{
printf("%s Could not load driver '%s'.\n", MixerError, driverpathname );
return FALSE ;
}
drvr=DLL_load(dll,DLLMEM_ALLOC | DLLSRC_MEM,NULL);
if (drvr==NULL)
{
printf("%s Invalid DLL image.\n", MixerError );
return FALSE ;
}
Free(dll);
Mixer_listfcts = *(void **)drvr;
printf("%s", drvr+4);
return (Mixer_Driver_Enable = TRUE);
}
/*-------------------------------------------------------------------------*/

1
SOURCES/MIXER.DEF Normal file
View File

@@ -0,0 +1 @@
extern long MixerInitDLL(char *);

3444
SOURCES/OBJECT.C Normal file
View File

File diff suppressed because it is too large Load Diff

28
SOURCES/OBJECT.DEF Normal file
View File

@@ -0,0 +1,28 @@
extern void InitObject(short );
extern void StartInitObj(short );
extern void StartInitAllObjs(void);
extern void LoadFicPerso(void);
extern void InitPerso(void);
extern void SetComportement(short );
extern void RestartPerso(void);
extern void ClearFlagsCube(void);
extern void ClearScene(void);
extern void ChangeCube(void);
extern void HitObj(short ,short ,short ,short );
extern long CheckZvOnZv(short ,short );
extern short CheckObjCol(short );
extern void CheckCarrier(short );
extern long CheckValidObjPos(short );
extern void InitBody(unsigned char ,short );
extern void InitSprite(short ,short );
extern short InitAnim(unsigned char ,short ,unsigned char ,short );
extern void ReajustPos(unsigned char );
extern void ReceptionObj(void);
extern void DoCornerReajust(short ,short ,short ,short );
extern void DoCornerReajustTwinkel(short ,short ,short ,short );
extern void DoAnim(short );
extern void ManualRealAngle(T_OBJET *);
extern void ClearRealAngle(T_OBJET *);
extern void DoDir(short );
extern void AffScene(long );
extern void CheckZoneSce(T_OBJET *,short );

1478
SOURCES/PERSO.C Normal file
View File

File diff suppressed because it is too large Load Diff

11
SOURCES/PERSO.DEF Normal file
View File

@@ -0,0 +1,11 @@
extern void InitGameLists(void);
extern void InitGame(int ,unsigned char **);
extern void Introduction(void);
extern long MainLoop(void);
extern void ReadVolumeSettings(void);
extern void WriteVolumeSettings(void);
extern void InitProgram(void);
extern void TheEnd(short ,unsigned char *);
extern int __far Critical_Error_Handler(unsigned int ,unsigned int ,unsigned int __far *);
extern void Message(unsigned char *,short );
extern void main(int ,unsigned char **);

703
SOURCES/PLAYFLA.C Normal file
View File

@@ -0,0 +1,703 @@
// **************************************************************
// * P L A Y F L A . C *
// * (c) Adeline 1994 *
// **************************************************************
#include "c_extern.h"
typedef struct { ULONG SizeFile ;
ULONG CompressedSizeFile ;
WORD CompressMethod ; /* 0 stored */
/* 1 LZS */
} T_HEADER ;
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
ÛßßßÛ Û ÛßßßÛ Û Üß Ûßßßß Û ÛßßßÛ
ÛÛßßß ÛÛ ÛÛßßÛ ÛÛß ÛÛßß ÛÛ ÛÛßßÛ
ßß ßßßßß ßß ß ßß ßß ßßßßß ßß ß
*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
#define FLI 2
#define FLA 3
#define X_POS_MENU_PRINCIPAL 480
#define Y_POS_MENU_PRINCIPAL 10
#define X_POS_MENU_STORYBOARD 0
#define Y_POS_MENU_STORYBOARD 335
// Define pour les fichiers format FLI
#define FLI_COLOR 11
#define FLI_LC 12
#define FLI_BLACK 13
#define FLI_BRUN 15
#define FLI_COPY 16
// Structures utilis‚es pour les fichiers format FLI
typedef struct
{
LONG size ;
UWORD type ;/* = FLIH_MAGIC */
UWORD frame_count ;
UWORD width ;
UWORD height ;
UWORD bits_a_pixel ;
WORD flags ;
WORD speed ;
LONG next_head ;
LONG frames_in_table ;
WORD file ;
LONG frame1_off ;
LONG strokes ;
LONG session ;
BYTE reserved[88] ;
} T_HEADER_FLI ;
typedef struct
{
ULONG size ;
UWORD typedata ;
UBYTE image[] ;
} T_HEADER_IMAGE ;
typedef struct
{
ULONG offset ;
UWORD signature ;
UWORD nbpasse ;
UBYTE reserved[6+2] ;
} T_HEADER_SUB ;
// Define pour les fichiers format FLA
#define VERSION "V1.3"
#define FLA_PALETTE 1
#define FLA_INFO 2
#define FLA_SAMPLE 3
#define FLA_SAMPLE_BALANCE 4
#define FLA_SAMPLE_STOP 5
#define FLA_LC 6
#define FLA_BLACK 7
#define FLA_BRUN 8
#define FLA_COPY 9
// Structures utilis‚es pour les fichiers format FLA
typedef struct // entete de fichier FLA
{
char Version[5] ;
ULONG NbFrame ;
UBYTE CadenceAnimation;
UWORD ResolutionX ;
UWORD ResolutionY ;
} T_HEADER_FLA;
typedef struct // header de passe
{
UBYTE NbPasse ;
ULONG OffsetFrameSuivante ;
} T_HEADER_FLA_PASSE;
typedef struct // structure d'un type de passe
{
UBYTE Type;
UWORD OffsetPasseSuivante;
} T_FLA_TYPE;
typedef struct // structure d'un element d'une liste de son
{
WORD NbSample;
WORD OffsetFrameOne;
} T_FLA_SAMPLE_LIST;
typedef struct // structure d'une info
{
WORD Info ;
} T_FLA_INFO;
typedef struct // structure d'un son
{
WORD Numero ;
WORD Decalage;
WORD Repetition;
UBYTE Balance;
UBYTE VolumeG;
UBYTE VolumeD;
} T_FLA_SAMPLE;
typedef struct // structure d'un son
{
WORD Numero ;
UBYTE Offset ;
WORD Balance ;
UBYTE VolumeG ;
UBYTE VolumeD ;
} T_FLA_BALANCE;
typedef struct // structure d'arret de son
{
UWORD Numero ;
} T_FLA_SAMPLE_STOP;
typedef struct // structure d'une palette
{
UWORD NbCouleur;
UWORD CouleurDepart;
} T_FLA_PALETTE;
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
UBYTE *BufferFrame ;
//UBYTE TypeAnimCharge = FALSE ;
UBYTE PaletteOrg[768] ;
T_HEADER_FLA HeaderFla ;
T_FLA_SAMPLE_LIST HeaderSampleListFla;
T_HEADER_FLA_PASSE HeaderPasseFla ;
T_FLA_SAMPLE HeaderSampleFlaNew;
T_FLA_BALANCE HeaderBalanceFlaNew;
T_FLA_SAMPLE_STOP HeaderSampleStopFlaNew;
T_FLA_INFO HeaderInfo ;
LONG HandleFla ;
LONG DeltaX, DeltaY ;
LONG MaxPass ;
LONG MaxFrame ;
ULONG NbTip ;
WORD CouleurDepart ;
WORD NombreDeCouleur ;
ULONG ImageCadence = 12 ;
//WORD Frame =0 ;
//WORD ImageCourante = 0 ;
//WORD ImageDebut = 0 ;
//WORD ImageFin = 0 ;
WORD FlagFirst = TRUE ;
// *************************************************************************
// **************************************************************************
void ChangeBalance( WORD numsample, UBYTE offset, UBYTE volg, UBYTE vold )
{
WORD i;
BYTE flagtrouve = FALSE;
#ifndef SAMPLE_FLA_HQR
i = NbSampleJoue;
while ( (i > 0) AND ( flagtrouve == FALSE) )
{
if ( (PtrSampleJoue[i] & 0x0000ffff) == numsample )
{
// Message( Itoa(PtrSampleJoue[i]), FALSE );
// Message( Itoa((LONG)volg), TRUE );
// Message( Itoa((LONG)vold), TRUE );
WaveChangeVolume( PtrSampleJoue[i], (ULONG)volg, (ULONG)vold );
flagtrouve = TRUE;
}
i--;
}
#endif
}
/*-------------------------------------------------------------------------*/
void LoadNextFrameFla()
{
Read( HandleFla, &HeaderPasseFla, sizeof( T_HEADER_FLA_PASSE)) ;
MaxPass = HeaderPasseFla.NbPasse ;/* pti->nbpasse*/
// Texte pour le debug
/* Box(10,420,500,450,0);
AffString (10,420,"Structure entete de passe:");
Text (10,430,"header_passe.NbPasse=%L", HeaderPasseFla.NbPasse);
Text (10,440,"header_passe.OffsetFrameSuivante=%L", HeaderPasseFla.OffsetFrameSuivante);
CopyBlockPhys(10,420,500,450); */
Read( HandleFla, BufferFrame, HeaderPasseFla.OffsetFrameSuivante);
}
/*-------------------------------------------------------------------------*/
void DrawNextFrameFla()
{
T_FLA_TYPE header_type;
T_FLA_PALETTE header_palette;
UBYTE *ptr_buffer, *ptr_donnee;
LONG i ;
LONG compteur ;
LoadNextFrameFla() ;
ptr_buffer = BufferFrame;
for ( i = 0 ; i < MaxPass ; i++ )
{
header_type = *(T_FLA_TYPE *)ptr_buffer;
ptr_buffer += sizeof(T_FLA_TYPE) ;/* Jump header type */
ptr_donnee = ptr_buffer ;
switch( header_type.Type )
{
case FLA_PALETTE:
header_palette = *(T_FLA_PALETTE *)ptr_donnee;
ptr_donnee += sizeof(T_FLA_PALETTE) ;/* Jump header type */
MovMem( ptr_donnee, PaletteOrg + header_palette.CouleurDepart * 3, header_palette.NbCouleur * 3 );
CouleurDepart = header_palette.CouleurDepart;
NombreDeCouleur = header_palette.NbCouleur;
break;
case FLA_SAMPLE:
HeaderSampleFlaNew = *(T_FLA_SAMPLE *)ptr_donnee;
ptr_donnee += sizeof(T_FLA_SAMPLE) ;/* Jump header type */
if( SamplesEnable )
{
HQ_MixSample( HeaderSampleFlaNew.Numero,
HeaderSampleFlaNew.Decalage,
HeaderSampleFlaNew.Repetition,
HeaderSampleFlaNew.VolumeG,
HeaderSampleFlaNew.VolumeD );
}
break;
case FLA_SAMPLE_BALANCE:
HeaderBalanceFlaNew = *(T_FLA_BALANCE *)ptr_donnee;
ptr_donnee += sizeof(T_FLA_BALANCE) ;/* Jump header type */
if( SamplesEnable )
{
ChangeBalance( HeaderBalanceFlaNew.Numero,
HeaderBalanceFlaNew.Offset,
HeaderBalanceFlaNew.VolumeG,
HeaderBalanceFlaNew.VolumeD );
}
break;
case FLA_SAMPLE_STOP:
HeaderSampleStopFlaNew = *(T_FLA_SAMPLE_STOP *)ptr_donnee;
ptr_donnee += sizeof(T_FLA_SAMPLE_STOP) ;/* Jump header type */
if ( SamplesEnable == TRUE )
{
if ( HeaderSampleStopFlaNew.Numero == -1 )
{
HQ_StopSample();
}
else
{
HQ_StopOneSample ( HeaderSampleStopFlaNew.Numero );
}
}
break;
case FLA_INFO:
HeaderInfo = *(T_FLA_INFO *)ptr_donnee;
ptr_donnee += sizeof(T_FLA_INFO) ;/* Jump header type */
switch( HeaderInfo.Info )
{
case 1: // fla flute
if( Midi_Driver_Enable )
{
if( (26 != NumXmi)
OR (!IsMidiPlaying()) )
{
StopMusicMidi() ;
PtrXmi = HQR_Get( HQR_Midi, 26 ) ;
NumXmi = 26 ;
PlayMidi( PtrXmi ) ;
VolumeMidi( 100 ) ;
}
}
break ;
case 2:
FadeToBlack( PaletteOrg ) ;
break ;
case 3:
FlagFirst = TRUE ;
break ;
case 4:
FadeMusicMidi( 1 ) ;
break ;
}
break;
case FLA_BLACK:
BlackFrame() ;
break ;
case FLA_COPY:
CopyFrame( ptr_donnee);
break ;
case FLA_BRUN:
DrawFrame( ptr_donnee, 320, DeltaY ) ;
break ;
case FLA_LC:
UpdateFrame( ptr_donnee, 320 ) ;
break ;
case FLI_COPY:
CopyFrame( ptr_donnee );
break ;
default:
break ;
}
ptr_buffer += header_type.OffsetPasseSuivante ;
} // fin boucle de passe
}
/*-------------------------------------------------------------------------*/
/*
void SeekFla()
{
T_FLA_SAMPLE_LIST header_sample_list;
Seek( HandleFla, sizeof(T_HEADER_FLA), SEEK_START ) ;
Read( HandleFla, &HeaderSampleListFla, sizeof(T_FLA_SAMPLE_LIST));
Seek( HandleFla, HeaderSampleListFla.OffsetFrameOne, SEEK_CURRENT );
}
*/
/*-------------------------------------------------------------------------*/
WORD InitFla( char *name )
{
char chaine[128] ;
UBYTE *ptr_list_sample ;
WORD i ;
WORD numero_sample ;
WORD nb_fois_joue ;
LONG size ;
BufferFrame = Screen ; // Malloc( 80000L ) For One Frame(image, couleur...)
HandleFla = OpenRead( name ) ;
#ifdef DEBUG_TOOLS
if ( !HandleFla ) return(FALSE) ; // protect CD ?
#endif
#ifdef DEMO
if ( !HandleFla ) return(FALSE) ; // protect CD ?
#endif
if( SamplesEnable )
{
UBYTE string[256] ;
strcpy( string, PathFla ) ;
strcat( string, "FLASAMP.HQR" ) ;
HQR_Change_Ressource( HQR_Samples, string ) ;
}
// lecture de l'entˆte principale
Read( HandleFla, &HeaderFla, sizeof(T_HEADER_FLA)) ;
MaxFrame = HeaderFla.NbFrame;
DeltaX = HeaderFla.ResolutionX ;
DeltaY = HeaderFla.ResolutionY ;
ImageCadence = HeaderFla.CadenceAnimation;
// lecture de la liste des samples
Read( HandleFla, &HeaderSampleListFla, sizeof(T_FLA_SAMPLE_LIST));
for ( i = 0; i < HeaderSampleListFla.NbSample; i++ )
{
Read( HandleFla, &numero_sample, sizeof(WORD));
Read( HandleFla, &nb_fois_joue, sizeof(WORD));
// preload samples (if enough space)
// (but if not, stupid method. need to write the
// list reversed)
if( SamplesEnable )
{
HQR_GetSample( HQR_Samples, numero_sample ) ;
}
}
// texte de debug
/* AffString (10,330,"Structure entete de fichier FLA:");
Text( 10,340,"HeaderFla.Version=%S", HeaderFla.Version );
Text( 10,350,"HeaderFla.NbFrame=%L", HeaderFla.NbFrame );
Text( 10,360,"HeaderFla.CadenceAnimation=%L", HeaderFla.CadenceAnimation );
Text( 10,370,"HeaderFla.ResolutionX=%L", HeaderFla.ResolutionX );
Text( 10,380,"HeaderFla.ResolutionY=%L", HeaderFla.ResolutionY );
Flip(); */
return TRUE ;
}
/*-------------------------------------------------------------------------*/
void ClearFla()
{
if( SamplesEnable )
{
HQR_Change_Ressource( HQR_Samples, PATH_RESSOURCE"samples.hqr" ) ;
}
Close( HandleFla ) ;
}
/*--------------------- GESTION PALETTE PENDANT ANIM ----------------------*/
void GestionPalette()
{
WORD compteur;
if( FlagFirst )
{
FadeToPal( PaletteOrg ) ;
NombreDeCouleur = 0 ;
FlagFirst = FALSE ;
}
if ( NombreDeCouleur != 0 )
{
if ( NombreDeCouleur == 256 )
{
Palette( PaletteOrg ) ;
}
else
{
/* for ( compteur=0; compteur<NombreDeCouleur; compteur++ )
{
PalOne( CouleurDepart+compteur, *(UBYTE *)PaletteOrg+(CouleurDepart+compteur)*3+0,
*(UBYTE *)PaletteOrg+(CouleurDepart+compteur)*3+1,
*(UBYTE *)PaletteOrg+(CouleurDepart+compteur)*3+2 );
}// LORAN LE 28/09/94
*/
PalMulti( CouleurDepart, NombreDeCouleur, PaletteOrg+(CouleurDepart*3) ) ;
}
NombreDeCouleur = 0;
}
}
//***************************************************************************
void PlayAnimFla(char *name_anim)
{
WORD i ;
ULONG cadence;
UBYTE sortie = FALSE;
UBYTE ficname[_MAX_PATH] ;
if( !FlaFromCD )
{
PlayDiskFla( name_anim ) ;
return ;
}
#ifdef CDROM
StopMusicCD() ;
#endif
strcpy( ficname, PathFla ) ;
strcat( ficname, name_anim ) ;
AddExt( ficname, ".FLA" ) ;
if( !InitFla( ficname ) ) return ;
if ( strcmp( HeaderFla.Version, VERSION ) == 0 )
{
ExtInitMcga();
SetBlackPal();
Mcga_Cls();
Mcga_Flip();
Mcga_Cls();
i=0;
FlagFirst = TRUE ;
while (sortie == FALSE )
{
if( Key == K_ESC ) sortie = TRUE;
cadence = TimerRef;
DrawNextFrameFla();
Mcga_Flip();
GestionPalette();
do
{
NbTip = TimerRef - cadence;
}
while (NbTip < 50 / ImageCadence);
i++;
if( i == MaxFrame ) sortie = TRUE ;
}
FadeToBlack( PaletteOrg ) ;
Mcga_Cls() ;
Mcga_Flip() ;
HQ_StopSample();
ClearFla();
ExtInitSvga() ;
SetBlackPal() ;
Cls() ;
}
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*
ÛßßßÜ Û ÛÛßßß Û Üß Ûßßßß Û ÛßßßÛ
ÛÛ Û ÛÛ ßßßßÛ ÛÛßÜ ÛÛßß ÛÛ ÛÛßßÛ
ßßßß ßß ßßßßß ßß ß ßßßßß ßß ßßßßß ßß ß
*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
void CutPoint( UBYTE *ptr )
{
UBYTE c ;
do
{
c = *ptr ;
if( c == '.' )
{
*ptr = 0 ;
return ;
}
ptr++ ;
}
while( c!=0 ) ;
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
WORD SearchFla( UBYTE *name_anim, UBYTE *ptrtxt, LONG maxsize, UBYTE *ptrlist )
{
UBYTE string[256] ;
LONG n = 0 ;
LONG nb = 0 ;
UBYTE *ptrs, *ptrd ;
do
{
ptrd = string ;
while( (*ptrd++ = *ptrtxt++) > 32 ) n++ ;
ptrd[-1] = 0 ;
n++ ;
if( !stricmp( name_anim, string ) )
{
do
{
*ptrlist++ = atoi( ptrtxt ) ;
nb++ ;
while( *ptrtxt++ > 32 ) n++ ;
n++ ;
}
while( *ptrtxt > 32 ) ;
return nb ;
}
while( *ptrtxt++ >= 32 ) n++ ;
n++ ;
while( *ptrtxt++ < 32 ) n++ ;
n++ ;
ptrtxt-- ;
}
while( n < maxsize ) ;
return 0 ;
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/
void PlayDiskFla( UBYTE *name_anim )
{
UBYTE *ptrtxt ;
UBYTE string[256] ;
LONG size,n, nb, timer ;
UBYTE listindex[20] ;
size = HQRM_Load( PATH_RESSOURCE"ress.hqr", RESS_FLA_PCX, &ptrtxt ) ;
CHECK_MEMORY
if( !ptrtxt )
{
Message( "Not Enough Memory for fla_gif list", TRUE ) ;
return ;
}
strcpy( string, name_anim ) ;
CutPoint( string ) ;
nb = SearchFla( string, ptrtxt, size, listindex ) ;
if( !nb ) return ;
// FadeToBlack( PtrPal ) ;
for( n=0; n<nb; n++ )
{
switch( listindex[n] )
{
case 200:
Load_HQR( PATH_RESSOURCE"ress.hqr", Screen, RESS_BUMPER_PCR ) ;
CopyScreen( Screen, Log ) ;
Load_HQR( PATH_RESSOURCE"ress.hqr", PalettePcx, RESS_BUMPER_PAL ) ;
break ;
case 201:
Load_HQR( PATH_RESSOURCE"ress.hqr", Screen, RESS_TWINSUN_PCR ) ;
CopyScreen( Screen, Log ) ;
Load_HQR( PATH_RESSOURCE"ress.hqr", PalettePcx, RESS_TWINSUN_PAL ) ;
break ;
case 202:
Load_HQR( PATH_RESSOURCE"ress.hqr", Screen, RESS_INTRO_2_PCR ) ;
CopyScreen( Screen, Log ) ;
Load_HQR( PATH_RESSOURCE"ress.hqr", PalettePcx, RESS_INTRO_2_PAL ) ;
break ;
default:
/* // methode avec PCX raw format
Load_HQR( PATH_RESSOURCE"fla_pcx.hqr", Screen, listindex[n]+1 ) ;
CopyScreen( Screen, Log ) ;
Load_HQR( PATH_RESSOURCE"fla_pcx.hqr", PalettePcx, listindex[n] ) ;
*/
{
LONG handle ;
UWORD nbbloc ;
ULONG buffer ;
ULONG seekindex ;
T_HEADER header ;
// entete hqr
handle = OpenRead( PATH_RESSOURCE"fla_gif.hqr" ) ;
if( !handle ) break ;
Read( handle, &buffer, 4L ) ;
nbbloc = (UWORD)(buffer / 4L) ;
if( listindex[n] >= nbbloc )
{
Close( handle ) ;
break ;
}
Seek( handle, listindex[n] * 4L, SEEK_START ) ;
Read( handle, &seekindex, 4L ) ;
Seek( handle, seekindex, SEEK_START ) ;
Read( handle, &header, sizeof( header ) ) ;
// methode de compression: stored
// lit un gif normal
Read_Gif( handle, Log, PalettePcx, BufSpeak ) ;
Close( handle ) ;
}
break;
}
Flip() ;
FadeToPal( PalettePcx ) ;
timer = TimerRef + 4 * 50 ;
while( TimerRef < timer ) if( Key == K_ESC ) break ;
if( Key == K_ESC ) break ;
FadeToBlack( PalettePcx ) ;
}
SetBlackPal() ;
Cls() ;
Flip() ;
HQM_Free( ptrtxt ) ;
}
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ*/

10
SOURCES/PLAYFLA.DEF Normal file
View File

@@ -0,0 +1,10 @@
extern void ChangeBalance(short ,unsigned char ,unsigned char ,unsigned char );
extern void LoadNextFrameFla(void);
extern void DrawNextFrameFla(void);
extern short InitFla(char *);
extern void ClearFla(void);
extern void GestionPalette(void);
extern void PlayAnimFla(char *);
extern void CutPoint(unsigned char *);
extern short SearchFla(unsigned char *,unsigned char *,long ,unsigned char *);
extern void PlayDiskFla(unsigned char *);

108
SOURCES/SETUP.DBG Normal file
View File

@@ -0,0 +1,108 @@
* window settings
display assembly /open {Assembly: *} 24,34,1,66
display command /close {Command Window} 3,8,47,66 {}
display dialogue /open {Dialogue: *} 43,49,1,80
display fpu /close {FPU} 3,12,1,73
display memory /open {Memory Window} 35,42,1,80,0000:0000
display prompt /open {} 50
display register /open {CPU} 3,22,67,80
display source /open {Source: *} 3,23,1,66
display stack /open {Stack} 23,34,67,80
display thread /close {Threads} 38,49,10,32
* window colours
paint assembly plain black,white
paint assembly active black,red
paint assembly standout black,cyan
paint assembly title bright blue,white
paint assembly gadget bright blue,white
paint command plain black,white
paint command active black,red
paint command standout black,cyan
paint command title bright blue,white
paint command gadget bright blue,white
paint dialogue plain black,white
paint dialogue active black,red
paint dialogue standout black,cyan
paint dialogue title bright blue,white
paint dialogue gadget bright blue,white
paint fpu plain black,white
paint fpu active black,red
paint fpu standout black,cyan
paint fpu title bright blue,white
paint fpu gadget bright blue,white
paint memory plain black,white
paint memory active black,red
paint memory standout black,cyan
paint memory title bright blue,white
paint memory gadget bright blue,white
paint prompt plain black,white
paint prompt active black,red
paint prompt standout black,cyan
paint prompt title bright blue,white
paint prompt gadget bright blue,white
paint register plain black,white
paint register active black,red
paint register standout black,cyan
paint register title bright blue,white
paint register gadget bright blue,white
paint source plain black,white
paint source active black,red
paint source standout black,cyan
paint source title bright blue,white
paint source gadget bright blue,white
paint stack plain black,white
paint stack active black,red
paint stack standout black,cyan
paint stack title bright blue,white
paint stack gadget bright blue,white
paint thread plain black,white
paint thread active black,red
paint thread standout black,cyan
paint thread title bright blue,white
paint thread gadget bright blue,white
* debugger settings
set assembly lower outside
set bell on
set call /near(eax,edx,ebx,ecx)eax
set dclick 250
set fpu decimal
set implicit on
set input prompt
set pfkey 1 {help}
set pfkey 4 { if !?_dbg@pf_4 {/_dbg@pf_4=0}; if (++_dbg@pf_4)&1 {disp fpu /o} {disp fpu /c} }
set pfkey 5 {reg -1}
set pfkey 6 {reg +1}
set pfkey 7 {/++_dbg@dbg$wind_split;<wind}
set pfkey 8 { if !?_dbg@pf_8 {/_dbg@pf_8=0}; if (++_dbg@pf_8)&1 {set menu off;<wind} {set menu on;<wind} }
set pfkey 10 {set menu activate}
set pfkey 39 {set input source}
set pfkey 40 {set input assembly}
set radix /0n 10
set radix /0x 16
set radix /0 8
set radix 10
set source
set symbol /ignore {*}{*_}{_*}
set tab 8
set visible assembly 0,2,1
set visible source 0,2,1
set level mixed
set language c
set macro assembly 'G' {g}
set macro assembly 'g' {g dbg$code}
set macro assembly 'i' {t/a/i}
set macro assembly 'n' {t/a/n}
set macro assembly ' ' {t/a/o}
set macro assembly 'b' {b dbg$code}
set macro assembly 'c' {b/c/dbg$code}
set macro fpu 'b' {set fpu binary}
set macro fpu 'd' {set fpu decimal}
set macro source 'v' {view}
set macro source 'G' {g}
set macro source 'g' {g dbg$code}
set macro source 'i' {t/s/i}
set macro source 'n' {t/s/n}
set macro source ' ' {t/s/o}
set macro source 'b' {b dbg$code}
set macro source 'c' {b/c/dbg$code}
set menu on

17
SOURCES/VERSION.C Normal file
View File

@@ -0,0 +1,17 @@
#include "c_extern.h"
#include <process.h>
#ifdef DEMO
char *Version = "LBA Demo ("
__DATE__
" / "
__TIME__
")\n" ;
#else
char *Version = "LBA/Relentless ("
__DATE__
" / "
__TIME__
")\n" ;
#endif

1
SOURCES/WD.BAT Normal file
View File

@@ -0,0 +1 @@
wvideo /trap=rsi /vga50 /swap %1 %2 %3 %4 %5 %6 %7 %8 %9