1563 lines
37 KiB
C
1563 lines
37 KiB
C
/*-------------------------------------------------------------------------*/
|
|
#ifdef TITRE
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
█┐ █┐ ██████┐ ██████┐ ██████┐ ██████┐ ██████┐ ██████┐
|
|
// ██┐ ██│ ██┌───┘ ██┌───┘ ██┌───┘ ██┌─██│ ██┌───┘ ██┌───┘
|
|
██████│ █████┐ ██████┐ ██████┐ ██████│ ██│███┐ █████┐
|
|
// ██┌─██│ ██┌──┘ └───██│ └───██│ ██┌─██│ ██│└██│ ██┌──┘
|
|
██│ ██│ ██████┐ ██████│ ██████│ ██│ ██│ ██████│ ██████┐
|
|
└─┘ └─┘ └─────┘ └─────┘ └─────┘ └─┘ └─┘ └─────┘ └─────┘
|
|
/*-------------------------------------------------------------------------*/
|
|
#endif
|
|
|
|
//#define CRYPTAGE 1
|
|
|
|
|
|
//#define LORAN 1
|
|
//#define LBA_EDITOR 1
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
#ifdef LORAN
|
|
#include "f:\projet\lib386\lib_sys\adeline.h"
|
|
#include "f:\projet\lib386\lib_sys\lib_sys.h"
|
|
#include "f:\projet\lib386\lib_svga\lib_svga.h"
|
|
#include "f:\projet\lib386\lib_menu\lib_menu.h"
|
|
#include "f:\projet\lib386\lib_cd\lib_cd.h"
|
|
#include "f:\projet\lib386\lib_3d\lib_3d.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <conio.h>
|
|
#include <dos.h>
|
|
#include <i86.h>
|
|
#else
|
|
#include "c_extern.h"
|
|
#endif
|
|
#ifdef LORAN
|
|
//================================================================= L O R A N
|
|
#define PathConfigFile "c:\\adeline.def"
|
|
#define CDROM 1
|
|
|
|
LONG Island ;
|
|
extern UBYTE *BufSpeak ;
|
|
/*-------------------------------------------------------------------------*/
|
|
void DrawCadre( LONG x0, LONG y0, LONG x1, LONG y1 )
|
|
{
|
|
Rect( x0, y0, x1, y1, 15 ) ;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void *LoadTestMalloc( char *name )
|
|
{
|
|
return(LoadMalloc(name)) ;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
LONG GetMusicCD()
|
|
{
|
|
return(GetMusicCDR()) ;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void StopMusicCD()
|
|
{
|
|
StopCDR() ;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
UBYTE *Screen ;
|
|
UBYTE *LbaFont;
|
|
UBYTE *PalOrg ;
|
|
WORD QuickMessage = FALSE ;
|
|
//===========================================================================
|
|
#endif
|
|
|
|
#ifdef ONE_GAME_DIRECTORY
|
|
#define PATH_TXT ""
|
|
#define PATH_NAR ""
|
|
#else
|
|
#define PATH_TXT "f:\\projet\\lba\\text\\"
|
|
#define PATH_NAR "f:\\projet\\lba\\samples\\dial\\"
|
|
#endif
|
|
|
|
#ifdef CDROM
|
|
#define PATH_NAR_CD "\\LBA\\VOX\\"
|
|
#define PATH_NAR_HD "VOX\\"
|
|
#define MAX_FILE_VOICE 42 // SYS CRE GAM 0 1 2 3 4 5 6 7 8 9 10 * MaxLang
|
|
#define EXT_NAR ".VOX"
|
|
#define FROM_HD 0
|
|
#define FROM_CD 1
|
|
#endif
|
|
|
|
#define NAME_HQR_TEXT "TEXT.HQR"
|
|
#define MAX_TEXT_LANG 14 // Attention, pour 1 langue seulement!
|
|
#define INIT_CODE 01+02+1993
|
|
|
|
#define INTER_LINE 38
|
|
#define INTER_SPACE 7 // 16/08/94 de 5 a 7 !
|
|
#define INTER_LEAVE 2
|
|
|
|
#define MAX_CAR 32
|
|
#define SPEAK_SAMPLE 0x1234
|
|
/*-------------------------------------------------------------------------*/
|
|
static LONG Dial_X0=16 ;
|
|
static LONG Dial_Y0=334 ;
|
|
static LONG Dial_X1=639-16 ;
|
|
static LONG Dial_Y1=479-16 ;
|
|
static LONG DialMaxSize=((623-8)-(16+8));
|
|
|
|
static char BufLine[256] ;
|
|
static char *PtLine ;
|
|
static LONG SizeLine ;
|
|
static LONG NbSpace ;
|
|
static LONG NbBigSpace ;
|
|
static LONG SizeSpace ;
|
|
static LONG LenLine ;
|
|
static LONG SizeWord ;
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
static UBYTE BufferMultiText[256] ;
|
|
static LONG IslandMultiText = -1 ;
|
|
static LONG NumMultiText = -1 ;
|
|
|
|
LONG FlecheForcee = FALSE ;
|
|
static ULONG SaveTimerForCar;
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
UWORD MaxText ;
|
|
|
|
static char FileText[256] ;
|
|
|
|
#define NB_LANGUAGES 5
|
|
|
|
LONG Language = 1 ; // English
|
|
LONG LastFileInit=-1 ;
|
|
|
|
char *TabLanguage[] = {
|
|
// Ne pas toucher l'ordre cause HQR
|
|
"English",
|
|
"Français",
|
|
"Deutsch",
|
|
"Español",
|
|
"Italiano" } ;
|
|
|
|
|
|
char *ListLanguage[] = { "EN_", "FR_", "DE_", "SP_", "IT_" } ;
|
|
|
|
char *ListFileText[] = { "sys",
|
|
"cre",
|
|
"gam",
|
|
"000",
|
|
"001",
|
|
"002",
|
|
"003",
|
|
"004",
|
|
"005",
|
|
"006",
|
|
"007",
|
|
"008",
|
|
"009",
|
|
"010",
|
|
"011" } ;
|
|
// Fred flag de cadre shade
|
|
|
|
WORD FlagMessageShade = TRUE ;
|
|
|
|
typedef struct
|
|
{
|
|
WORD c ;
|
|
WORD x ;
|
|
WORD y ;
|
|
|
|
} T_STACKCAR ;
|
|
|
|
static T_STACKCAR StackCar[MAX_CAR] ;
|
|
|
|
static LONG NbCar ;
|
|
|
|
static LONG NbDegrade ;
|
|
static LONG MinDegrade ;
|
|
static LONG MaxDegrade ;
|
|
static LONG StepDegrade ;
|
|
UBYTE *BufText=0L ;
|
|
static UBYTE *PtText=0L ;
|
|
static LONG SizeText ;
|
|
|
|
UWORD *BufOrder = 0L ;
|
|
|
|
LONG FlagSpeak=FALSE ;// cf InitLanguage
|
|
//------------------------------
|
|
#ifdef CDROM
|
|
WORD NumObjSpeak = -1 ;
|
|
LONG FlagVoiceCD=FALSE ;// cf InitLanguage
|
|
static LONG FlagKeepVoice=0 ;
|
|
LONG FlagDisplayText=1 ;// ON par default
|
|
static LONG FlagNextVoc=FALSE ;
|
|
ULONG *BufMemoSeek=0 ;
|
|
static ULONG FdNar=0 ;
|
|
static ULONG FdCd=0 ;
|
|
typedef struct
|
|
{
|
|
char NameHD[13+sizeof(PATH_NAR_HD)] ;
|
|
ULONG SaveTimer ;
|
|
ULONG SizeFileHD ;
|
|
|
|
} T_FILEONHD ;
|
|
|
|
T_FILEONHD TabFileOnHD[MAX_FILE_VOICE] ;
|
|
|
|
ULONG TotalSizeFileHD = 0 ;
|
|
LONG LanguageCD = 0 ;// Français, a changer of course!
|
|
LONG NbFileOnHD = 0 ;// No File for the moment
|
|
LONG MaxVoice=0 ;
|
|
#endif
|
|
//------------------------------
|
|
|
|
static char *PtDial ;
|
|
static char Word[256] ;
|
|
static char *PtWord ;
|
|
static LONG X_Dial, Y_Dial ;
|
|
static LONG NbLineDial ;
|
|
static LONG MaxLineDial=3 ;
|
|
static LONG FlagEnd3Line=FALSE;
|
|
static LONG FlagRunningDial=FALSE;
|
|
static LONG FlagEndDial=FALSE;
|
|
static LONG CurrentDial=0 ;
|
|
static LONG LenWord ;
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
void TimeBar( ULONG max, ULONG val )
|
|
{
|
|
ULONG x, dx ;
|
|
|
|
MemoClip() ;
|
|
UnSetClip() ;
|
|
|
|
CopyBlock( 16, 400, 623, 440, Log, 16, 400, Screen );
|
|
|
|
x = RegleTrois32( 17, 622, max, val ) ;// Lib_3D
|
|
|
|
PalOne( 14, 23,0,64 ) ;
|
|
PalOne( 15, 0,255,255 ) ;
|
|
|
|
Rect( 16, 400, 623, 440, 15 ) ;
|
|
Box( 17, 401, x, 439, 14 ) ;
|
|
|
|
CoulFont( 15 ) ;
|
|
dx = SizeFont( PleaseWait ) ;
|
|
Font( 320-dx/2, 400, PleaseWait );
|
|
|
|
CopyBlockPhys( 16, 400, 623, 440 );
|
|
|
|
CopyBlock( 16, 400, 623, 440, Screen, 16, 400, Log );
|
|
|
|
RestoreClip() ;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
void InitLanguage()
|
|
{
|
|
UBYTE string[256] ;
|
|
LONG n ;
|
|
|
|
strcpy( string, Def_ReadString( PathConfigFile, "Language" ) ) ;
|
|
|
|
for( n=0; n<NB_LANGUAGES; n++ )
|
|
{
|
|
if( !stricmp( string, TabLanguage[n] ) )
|
|
{
|
|
Language = n ;
|
|
break ;
|
|
}
|
|
}
|
|
|
|
#ifdef CDROM
|
|
strcpy( string, Def_ReadString( PathConfigFile, "LanguageCD" ) ) ;
|
|
|
|
FlagSpeak = FALSE ;
|
|
|
|
for( n=0; n<NB_LANGUAGES; n++ )
|
|
{
|
|
if( !stricmp( string, TabLanguage[n] ) )
|
|
{
|
|
LanguageCD = n ;
|
|
FlagSpeak = TRUE;
|
|
break ;
|
|
}
|
|
}
|
|
|
|
if ( !Wave_Driver_Enable ) FlagSpeak = FALSE ;// No Sound PC
|
|
|
|
strcpy( string, Def_ReadString( PathConfigFile, "FlagKeepVoice" ) ) ;
|
|
if ( !strcmpi( string, "ON" )) FlagKeepVoice = 1 ;
|
|
else FlagKeepVoice = 0 ;// default
|
|
|
|
strcpy( string, Def_ReadString( PathConfigFile, "FlagDisplayText" ) ) ;
|
|
if ( !strcmpi( string, "OFF" )) FlagDisplayText = 0 ;
|
|
else FlagDisplayText = 1 ;// default
|
|
#endif
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
LONG FindText( LONG text )
|
|
{
|
|
UWORD *pt ;
|
|
LONG i ;
|
|
|
|
pt = BufOrder ;
|
|
|
|
for ( i = 0 ; i < MaxText ; i++ )
|
|
{
|
|
if ( *pt++ == text ) return( i ) ;
|
|
}
|
|
return( -1 ) ;
|
|
}
|
|
#ifdef TITRE
|
|
/*-------------------------------------------------------------------------*/
|
|
█▀▀▀▀ █▀▀▀▄ █▀▀▀█ █▀▀▀█ █▄ ▄█ █▀▀▀█ █▀▀▀█ █▀▀▀█ ▀▀█▀▀
|
|
// ██ ██ █ ██▀█▀ ██ █ ██▀ █ ██▀▀▀ ██▀▀█ ██▀█▀ ██
|
|
▀▀▀▀▀ ▀▀▀▀ ▀▀ ▀ ▀▀▀▀▀ ▀▀ ▀ ▀▀ ▀▀ ▀ ▀▀ ▀ ▀▀
|
|
/*-------------------------------------------------------------------------*/
|
|
#endif
|
|
#ifdef CDROM
|
|
/*-------------------------------------------------------------------------*/
|
|
// Pour prendre en compte les eventuels fichiers déjà sur HD
|
|
void InitVoiceFile()
|
|
{
|
|
char pathname[_MAX_PATH];
|
|
struct find_t fileinfo;
|
|
ULONG time ;
|
|
ULONG rc ;
|
|
|
|
rc = _dos_findfirst( PATH_NAR_HD"*.VOX", _A_NORMAL, &fileinfo ) ;
|
|
|
|
while( !rc )
|
|
{
|
|
time = fileinfo.wr_date ;
|
|
time += fileinfo.wr_time ;
|
|
strcpy( pathname, PATH_NAR_HD ) ;
|
|
strcat( pathname, fileinfo.name);
|
|
AddFileNameOnHD( pathname, fileinfo.size, time ) ;
|
|
#ifdef LORAN
|
|
AffStatusVoiceFile() ;
|
|
#endif
|
|
rc = _dos_findnext( &fileinfo ) ;
|
|
}
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void ClearVoiceFile()
|
|
{
|
|
T_FILEONHD *pt ;
|
|
LONG i ;
|
|
|
|
if ( FlagKeepVoice ) return ;
|
|
|
|
#ifdef DEBUG_TOOLS
|
|
Message("FlagKeepVoice=0 !!!!!", TRUE ) ;
|
|
return ;
|
|
#endif
|
|
|
|
pt = TabFileOnHD;
|
|
|
|
for ( i = 0 ; i < NbFileOnHD ; i++, pt++ )
|
|
{
|
|
if ( FileSize( pt->NameHD ))// On ne sait jamais,
|
|
Delete( pt->NameHD );// un bug est si vite arrive :-o
|
|
}
|
|
|
|
TotalSizeFileHD = 0 ;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void CalcTotalSizeFileOnHD()
|
|
{
|
|
T_FILEONHD *pt ;
|
|
LONG i ;
|
|
|
|
TotalSizeFileHD = 0 ;
|
|
pt = TabFileOnHD ;
|
|
|
|
for ( i = 0 ; i < NbFileOnHD ; i++, pt++ )
|
|
TotalSizeFileHD += pt->SizeFileHD ;
|
|
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
#ifdef LORAN
|
|
void AffStatusVoiceFile()
|
|
{
|
|
T_FILEONHD *pt ;
|
|
LONG i ;
|
|
|
|
Text( 10, 8, "%FStatus des fichiers voix :") ;
|
|
|
|
pt = TabFileOnHD;
|
|
for ( i = 0 ; i < NbFileOnHD ; i++, pt++ )
|
|
{
|
|
Text( 10, i*10+16, "%FName : %s Size : %L Time : %L", pt->NameHD, pt->SizeFileHD, pt->SaveTimer ) ;
|
|
}
|
|
while( !Key ) ;
|
|
while( Key ) ;
|
|
}
|
|
#endif
|
|
/*-------------------------------------------------------------------------*/
|
|
void AddFileNameOnHD( char *filename, ULONG size, ULONG timer )
|
|
{
|
|
T_FILEONHD *pt ;
|
|
LONG i ;
|
|
|
|
pt = TabFileOnHD ;
|
|
|
|
for ( i = 0 ; i < NbFileOnHD ; i++, pt++ )
|
|
{
|
|
if ( !strcmp( pt->NameHD, filename )) break ;
|
|
}
|
|
|
|
strcpy( pt->NameHD, filename ) ;// Eventuelle recopie...
|
|
pt->SaveTimer = timer ;
|
|
pt->SizeFileHD = size ;
|
|
|
|
if ( i == NbFileOnHD ) NbFileOnHD++ ;// Maj ou Add
|
|
|
|
CalcTotalSizeFileOnHD() ;// Place prise
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void DeleteOlderFileHD()
|
|
{
|
|
T_FILEONHD *pt, *pt1 ;
|
|
LONG i ;
|
|
ULONG min, num ;
|
|
|
|
min = 0xFFFFFFFFL ;// le plus récent, non?
|
|
|
|
num = 0 ;// Suis obligé dans trouvé un!
|
|
|
|
pt = TabFileOnHD ;
|
|
|
|
for ( i = 0 ; i < NbFileOnHD ; i++, pt++ )
|
|
{
|
|
if ( pt->SaveTimer <= min )
|
|
{
|
|
min = pt->SaveTimer ;
|
|
num = i ;
|
|
}
|
|
}
|
|
|
|
pt-- ;// Stay on Last Entry
|
|
|
|
pt1 = &TabFileOnHD[num] ;
|
|
|
|
if ( FileSize( pt1->NameHD )) Delete( pt1->NameHD );// cf Del upper
|
|
|
|
TotalSizeFileHD -= pt1->SizeFileHD ;// Maj TotalSizeFileHD
|
|
|
|
strcpy( pt1->NameHD, pt->NameHD ) ;// Permut Current & Last
|
|
pt1->SaveTimer = pt->SaveTimer ;
|
|
NbFileOnHD-- ;// One less
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
// Copy File CD On HD ( filename for CD must don't contain drive !!!)
|
|
LONG CopyFileCD_HD( char *filecd, char *filehd )
|
|
{
|
|
ULONG fd ;
|
|
LONG size, wr;
|
|
LONG i, sect ;
|
|
char fname[256];
|
|
|
|
|
|
fname[0] = DriveCDR+'A' ;
|
|
fname[1] = ':' ;
|
|
fname[2] = 0 ;
|
|
strcat( fname, filecd ) ;
|
|
|
|
fd = OpenRead( fname ) ;
|
|
if ( !fd ) return(0);
|
|
Close(fd) ;
|
|
|
|
GetFileCDR( filecd ) ;// => FileCD_Start, FileCD_Sect & FileCD_Size
|
|
|
|
size = GetHDFreeSize() ;// HD Free Space
|
|
|
|
size -= (1024L*1024L) ;// 1 megas marge
|
|
|
|
if ( FileCD_Size >= size ) return(0);
|
|
|
|
fd = OpenWrite( filehd ) ;
|
|
if ( !fd ) return(0) ;
|
|
//------------------------------------------------ 64Ko fast copy :-)
|
|
sect = FileCD_Start+FileCD_Sect ;
|
|
size = FileCD_Size ;
|
|
|
|
for ( i = FileCD_Start ; i <= sect-32 ; i += 32 )
|
|
{
|
|
if (ReadLongCDR( i, 32, BufSpeak ))
|
|
{
|
|
Close(fd) ;
|
|
Delete( filehd );
|
|
return(0) ;
|
|
}
|
|
wr = Write( fd, BufSpeak, 256L*256L ) ;
|
|
if ( wr != 256L*256L )
|
|
{
|
|
Close(fd) ;
|
|
Delete( filehd );
|
|
return(0) ;
|
|
}
|
|
size -= (256L*256L) ;
|
|
TimeBar( FileCD_Size, FileCD_Size-size );
|
|
}
|
|
//------------------------------------------------ Copy left Bytes
|
|
sect -= i ;
|
|
|
|
if ( sect )
|
|
{
|
|
if (ReadLongCDR( i, sect, BufSpeak ))
|
|
{
|
|
Close(fd) ;
|
|
Delete( filehd );
|
|
return(0) ;
|
|
}
|
|
wr = Write( fd, BufSpeak, size ) ;
|
|
if ( wr != size ) // Juste a la fin ! :-(
|
|
{
|
|
Close(fd) ;
|
|
Delete( filehd );
|
|
return(0) ;
|
|
}
|
|
}
|
|
|
|
TimeBar( FileCD_Size, FileCD_Size );
|
|
Close(fd) ;
|
|
|
|
return(1) ;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
LONG TryCopyFileCD_HD( char *filecd, char *filehd )
|
|
{
|
|
ULONG freesize ;
|
|
|
|
freesize = GetHDFreeSize()-(1024L*1024L) ;// 1 Mega de marge
|
|
|
|
if (!GetFileCDR( filecd )) return(0);// Ne doit Jamais Arriver!
|
|
|
|
if ( freesize > FileCD_Size ) // Y a la place :-)
|
|
return( CopyFileCD_HD( filecd, filehd )) ;
|
|
|
|
//------------------------------ Ok, y a pas la place for the moment :-(
|
|
|
|
if ( !NbFileOnHD ) return(0) ;// Nothing to delete :-<
|
|
|
|
if ( TotalSizeFileHD+freesize < FileCD_Size )
|
|
return(0) ;// We can't do nothing :-[
|
|
|
|
while( freesize < FileCD_Size ) // Keep hope... ;-)
|
|
{
|
|
DeleteOlderFileHD() ;
|
|
freesize = GetHDFreeSize()-(1024L*1024L);
|
|
}
|
|
|
|
//----------------------------- Ok, maintenant on a forcément la place...
|
|
|
|
return( CopyFileCD_HD( filecd, filehd )) ;// :-)
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void CloseFdNar()
|
|
{
|
|
if ( FdNar )// Fichier ouvert CD ou HD, on doit le fermer
|
|
{
|
|
Close(FdNar) ;
|
|
FdNar = 0L ;
|
|
}
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void InitFileNar( char *file, LONG from )
|
|
{
|
|
ULONG offset, wr ;
|
|
|
|
CloseFdNar() ;
|
|
|
|
FlagVoiceCD = 0 ;//Je touche pas au CD pour le moment
|
|
|
|
if (( from == FROM_CD ) AND ( GetMusicCD() != -1 ))
|
|
StopMusicCD() ;
|
|
|
|
FdNar = OpenRead( file ) ;// CD or HD, it's working
|
|
// with FdNar, so... ;-)
|
|
if ( !FdNar ) return ;
|
|
|
|
offset = 0 ;
|
|
|
|
while(!offset) // Sans Filet
|
|
{
|
|
wr = Read( FdNar, &offset, 4L ) ;
|
|
}
|
|
|
|
MaxVoice = (offset/4)-1 ;// Normalement en phase
|
|
// avec MaxText mais bon,
|
|
// en chantier... {:) --D (un ouvrier, je sais, il est nul celui la, désolé...)
|
|
Seek( FdNar, 0L, SEEK_START ) ;
|
|
|
|
wr = Read( FdNar, BufMemoSeek, offset ) ;
|
|
if ( wr != offset )
|
|
{
|
|
CloseFdNar() ;
|
|
return ;
|
|
}
|
|
|
|
FlagVoiceCD = from ;// 0 si HD, 1 si CD (cf InitSpeak )
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
/*-------------------------------------------------------------------------*/
|
|
void InitSpeak( LONG file )
|
|
{
|
|
LONG size ;
|
|
char filehd[256] ;
|
|
char filenar[256] ;
|
|
|
|
// if ( DriveCDR < 0 ) return ;// a virer
|
|
|
|
strcpy( filehd, PATH_NAR_HD ) ;
|
|
strcat( filehd, ListLanguage[LanguageCD] );
|
|
strcat( filehd, ListFileText[file]) ;
|
|
AddExt( filehd, EXT_NAR) ;
|
|
|
|
if ( size = FileSize( filehd )) // Already on HD
|
|
{
|
|
AddFileNameOnHD( filehd, size, ComputeTime() );// Maj Timer
|
|
Touch( filehd ) ;
|
|
InitFileNar( filehd, FROM_HD ) ;
|
|
return ;
|
|
}
|
|
|
|
strcpy( filenar, PATH_NAR_CD ) ;
|
|
strcat( filenar, ListLanguage[LanguageCD] );
|
|
strcat( filenar, ListFileText[file]) ;
|
|
AddExt( filenar, EXT_NAR) ;
|
|
|
|
if ( GetMusicCD() != -1 ) StopMusicCD() ;
|
|
|
|
if ( !TryCopyFileCD_HD( filenar, filehd ) )
|
|
{
|
|
filehd[0] = DriveCDR+'A' ;
|
|
filehd[1] = ':' ;
|
|
filehd[2] = 0 ;
|
|
strcat( filehd, filenar ) ;
|
|
InitFileNar( filehd, FROM_CD ) ;// CD
|
|
}
|
|
else
|
|
{
|
|
AddFileNameOnHD( filehd, FileCD_Size, ComputeTime() );// FileCD_Size TryCopy...
|
|
InitFileNar( filehd, FROM_HD ) ;// HD
|
|
}
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void PlaySpeakVoc(LONG fd)
|
|
{
|
|
LONG size ;
|
|
LONG sizelzss;
|
|
WORD method ;
|
|
ULONG volleft = 512 ;
|
|
ULONG volright = 512 ;
|
|
|
|
|
|
Read( fd, &size, 4L ) ;
|
|
Read( fd, &sizelzss, 4L ) ;
|
|
Read( fd, &method, 2L ) ;
|
|
|
|
if ( method == 0 ) Read( fd, BufSpeak, size ) ;
|
|
else
|
|
{
|
|
CopyScreen( Screen, Log ) ;
|
|
Read( fd, Screen, sizelzss ) ;/* 256Ko ds Screen */
|
|
Expand( Screen, BufSpeak, size );
|
|
CopyScreen( Log, Screen ) ;
|
|
}
|
|
|
|
FlagNextVoc = *BufSpeak ;
|
|
/*
|
|
#ifndef LORAN
|
|
if( NumObjSpeak != -1 )
|
|
{
|
|
ProjettePoint( ListObjet[NumObjSpeak].PosObjX-WorldXCube,
|
|
ListObjet[NumObjSpeak].PosObjY-WorldYCube,
|
|
ListObjet[NumObjSpeak].PosObjZ-WorldZCube ) ;
|
|
|
|
GiveBalance( Xp, Yp, 724, &volleft, &volright ) ;
|
|
}
|
|
#endif
|
|
*/
|
|
// Loran, modif du 4/10/94 au cas ou SayMessage avant ( crac HP )
|
|
if ( WaveInList(SPEAK_SAMPLE)) WaveStopOne(SPEAK_SAMPLE) ;
|
|
|
|
#ifdef LORAN
|
|
WavePlay( SPEAK_SAMPLE, 0x1000, 1, 0, 1024, 1024, BufSpeak ) ;
|
|
#else
|
|
WavePlay( SPEAK_SAMPLE, 0x1000, 1, 0, volleft, volright, BufSpeak ) ;
|
|
#endif
|
|
|
|
NumObjSpeak = -1 ;
|
|
|
|
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
LONG TestSpk( LONG fd )
|
|
{
|
|
if ( !FlagSpeak ) return(0) ;// Le joueur ne veut pas
|
|
if ( !fd ) return(0) ;// Le programme ne peut pas
|
|
|
|
if ( WaveInList( SPEAK_SAMPLE )) return(1) ;// ça joue...
|
|
|
|
if ( FlagNextVoc ) // Ya une suite...
|
|
{
|
|
PlaySpeakVoc( fd ) ;// Scratch Screen
|
|
return(1) ;// Ca continue de jouer...
|
|
}
|
|
|
|
return(0) ; // A plus, snif... :-(
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
LONG TestSpeak()
|
|
{
|
|
return(TestSpk( FdNar ));
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
//#ifdef A_VOIR_SI_UTIL_STOP_MUSIC_BEFORE_PLAYING
|
|
|
|
LONG TestSpeakFromCD()
|
|
{
|
|
LONG ret ;
|
|
|
|
if ( DriveCDR < 0 ) return(0) ;
|
|
|
|
ret = TestSpk( FdCd ) ;
|
|
|
|
if (( !ret ) AND ( FdCd ))
|
|
{
|
|
Close(FdCd) ;
|
|
FdCd = 0L ;
|
|
}
|
|
|
|
return( ret ) ;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void SpeakFromCD( LONG file, LONG text )
|
|
{
|
|
UWORD *pt ;
|
|
LONG num, offset ;
|
|
LONG max ;
|
|
char tmpname[256] ;
|
|
|
|
if ( DriveCDR < 0 ) return ;
|
|
|
|
strcpy( tmpname, PATH_TXT ) ;// Pas FileText!
|
|
strcat( tmpname, ListLanguage[LanguageCD] ) ;
|
|
strcat( tmpname, ListFileText[file]) ;
|
|
AddExt( tmpname, ".ord") ;
|
|
|
|
|
|
//--------------------------------------
|
|
max = FileSize( tmpname )/2 ;
|
|
Load( tmpname, BufSpeak ) ;// Ne pas bousiller BufOrder!
|
|
|
|
pt = (UWORD*)BufSpeak ;
|
|
|
|
for ( num = 0 ; num < max ; num++ )
|
|
{
|
|
if ( *pt++ == text )
|
|
break ;
|
|
}
|
|
|
|
if ( num == max ) return ;
|
|
//--------------------------------------
|
|
|
|
tmpname[0] = DriveCDR+'A' ;
|
|
tmpname[1] = ':' ;
|
|
tmpname[2] = 0 ;
|
|
strcat( tmpname, PATH_NAR_CD ) ;
|
|
strcat( tmpname, ListLanguage[LanguageCD] ) ;
|
|
strcat( tmpname, ListFileText[file]) ;
|
|
AddExt( tmpname, EXT_NAR) ;
|
|
|
|
FdCd = OpenRead( tmpname ) ;
|
|
if ( !FdCd ) return ;
|
|
|
|
Seek( FdCd, num*4L, SEEK_START );
|
|
|
|
Read( FdCd, &offset, 4L ) ;
|
|
|
|
if ( !offset )
|
|
{
|
|
Close(FdCd) ;
|
|
return ;
|
|
}
|
|
|
|
Seek( FdCd, offset, SEEK_START );
|
|
PlaySpeakVoc(FdCd) ;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
LONG IsVoiceFileOnHD( LONG island )
|
|
{
|
|
char filehd[_MAX_PATH] ;
|
|
|
|
strcpy( filehd, PATH_NAR_HD ) ;
|
|
strcat( filehd, ListLanguage[LanguageCD] ) ;
|
|
strcat( filehd, ListFileText[island]) ;
|
|
AddExt( filehd, EXT_NAR) ;
|
|
|
|
if ( FileSize( filehd )) return( 1L ) ;
|
|
|
|
return(0L) ;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
LONG Speak( LONG text )
|
|
{
|
|
LONG num, offset ;
|
|
|
|
if ( !FdNar ) return(0L) ;
|
|
|
|
num = FindText( text ) ;
|
|
|
|
if (( num == -1 )
|
|
OR ( num >= MaxVoice )) return(0L) ;// Ne doit pas arrivé,
|
|
// sauf en cours de dvp...
|
|
offset = BufMemoSeek[num] ;
|
|
|
|
if ( !offset ) return(0L) ;
|
|
|
|
Seek( FdNar, offset, SEEK_START );
|
|
PlaySpeakVoc( FdNar ) ;
|
|
return(1L) ;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void StopSpeak()
|
|
{
|
|
FlagNextVoc = FALSE ;// Important, dans tout les cas !
|
|
if ( !FlagSpeak ) return ;
|
|
if ( !FdNar ) return ;
|
|
if ( WaveInList(SPEAK_SAMPLE)) WaveStopOne(SPEAK_SAMPLE) ;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
#endif
|
|
#ifdef TITRE
|
|
/*-------------------------------------------------------------------------*/
|
|
█▀▀▀▀ █▀▀▀▄ █▀▀▀█ █▀▀▀█ █▄ ▄█ █▀▀▀▀ ██▄ █ █▀▀▀▄
|
|
// ██ ██ █ ██▀█▀ ██ █ ██▀ █ ██▀▀ ██▀██ ██ █
|
|
▀▀▀▀▀ ▀▀▀▀ ▀▀ ▀ ▀▀▀▀▀ ▀▀ ▀ ▀▀▀▀▀ ▀▀ ▀ ▀▀▀▀
|
|
/*-------------------------------------------------------------------------*/
|
|
#endif
|
|
/*-------------------------------------------------------------------------*/
|
|
void InitDial( LONG file )
|
|
{
|
|
char *pt ;
|
|
LONG i, j, size ;
|
|
LONG offset0 ;
|
|
LONG offset1 ;
|
|
LONG code ;
|
|
|
|
if ( LastFileInit == file ) return ;
|
|
LastFileInit = file ;
|
|
|
|
#ifdef CRYPTAGE
|
|
strcpy( FileText, PATH_TXT ) ;
|
|
strcat( FileText, ListLanguage[Language] ) ;
|
|
strcat( FileText, ListFileText[file]) ;
|
|
AddExt( FileText, ".ord") ;
|
|
|
|
MaxText = FileSize( FileText ) / 2 ;/* WORD */
|
|
Load( FileText, BufOrder ) ;
|
|
AddExt( FileText, ".dia") ;
|
|
Load( FileText, BufText ) ;
|
|
//-------------------------- Decryptage
|
|
|
|
for ( i = 0 ; i < MaxText ; i++ )
|
|
{
|
|
offset0 = *(UWORD*)(BufText+(i+0)*2) ;
|
|
offset1 = *(UWORD*)(BufText+(i+1)*2) ;
|
|
|
|
size = offset1 - offset0 ;
|
|
|
|
code = INIT_CODE ;
|
|
|
|
pt = BufText + offset0 ;
|
|
|
|
for ( j = 0 ; j < size ; j++ )
|
|
*pt++ ^= (code++) ;
|
|
}
|
|
|
|
#else
|
|
strcpy( FileText, PATH_TXT ) ;
|
|
strcat( FileText, NAME_HQR_TEXT ) ;
|
|
|
|
MaxText = Load_HQR( FileText, BufOrder,
|
|
( Language*MAX_TEXT_LANG*2)+(file*2)+0)/2 ;
|
|
|
|
Load_HQR( FileText, BufText,
|
|
( Language*MAX_TEXT_LANG*2)+(file*2)+1) ;
|
|
|
|
|
|
#endif
|
|
|
|
#ifdef CDROM
|
|
if ( FlagSpeak ) InitSpeak(file) ;
|
|
#endif
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
/*-------------------------------------------------------------------------*/
|
|
void ClearDial()
|
|
{
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void GetNextWord(char *ptchaine, char *mot)
|
|
{
|
|
char *dst ;
|
|
|
|
dst = mot ;
|
|
LenWord = 0 ;
|
|
|
|
while(( *ptchaine != 0 )
|
|
AND ( *ptchaine != 1 )
|
|
AND ( *ptchaine != ' ' ))
|
|
{
|
|
*dst++ = *ptchaine++ ;
|
|
LenWord++ ;
|
|
}
|
|
|
|
*dst = 0 ;
|
|
SizeWord = SizeFont(mot) ;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void PushCar( LONG x, LONG y, LONG c )
|
|
{
|
|
LONG i ;
|
|
|
|
if ( NbCar < MAX_CAR )
|
|
{
|
|
StackCar[NbCar].c = c ;
|
|
StackCar[NbCar].x = x ;
|
|
StackCar[NbCar].y = y ;
|
|
NbCar++ ;
|
|
}
|
|
else
|
|
{
|
|
for ( i = 0 ; i < MAX_CAR-1 ; i++ )
|
|
{
|
|
StackCar[i].c = StackCar[i+1].c ;
|
|
StackCar[i].x = StackCar[i+1].x ;
|
|
StackCar[i].y = StackCar[i+1].y ;
|
|
}
|
|
StackCar[MAX_CAR-1].c = c ;
|
|
StackCar[MAX_CAR-1].x = x ;
|
|
StackCar[MAX_CAR-1].y = y ;
|
|
}
|
|
|
|
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void AffOneCar( LONG x, LONG y, LONG c, LONG coul )
|
|
{
|
|
LONG x0, y0, x1, y1 ;
|
|
|
|
if ( c != 32 )
|
|
{
|
|
#ifdef LBA_EDITOR
|
|
if ( !QuickMessage )
|
|
#endif
|
|
{
|
|
CoulFont( 0 ) ;
|
|
CarFont( x+2, y+4, c ) ;
|
|
}
|
|
CoulFont( coul ) ;
|
|
CarFont( x, y, c ) ;
|
|
x0 = x ;
|
|
y0 = y ;
|
|
x1 = x+32 ;
|
|
y1 = y+38 ;
|
|
if ( x0 < Dial_X0+1 ) x0 = Dial_X0+1 ;
|
|
if ( y0 < Dial_Y0+1 ) y0 = Dial_Y0+1 ;
|
|
if ( x1 > Dial_X1-1 ) x1 = Dial_X1-1 ;
|
|
if ( y1 > Dial_Y1-1 ) y1 = Dial_Y1-1 ;
|
|
|
|
CopyBlockPhys( x0, y0, x1, y1 ) ;
|
|
|
|
// CopyBlockPhys( x, y, x+32, y+38 );// Loran le 20/09/94
|
|
}
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void AffAllCar()
|
|
{
|
|
T_STACKCAR *pt ;
|
|
LONG i, c, x, y ;
|
|
|
|
|
|
c = MaxDegrade ;
|
|
|
|
pt = &StackCar[NbCar-1] ;
|
|
|
|
x = pt->x ;
|
|
y = pt->y ;
|
|
|
|
#ifdef LBA_EDITOR
|
|
if ( !QuickMessage )
|
|
#endif
|
|
while( SaveTimerForCar == TimerRef ) ;
|
|
|
|
SaveTimerForCar = TimerRef ;
|
|
|
|
for ( i = NbCar-1 ; i >= 0 ; i--, pt-- )
|
|
{
|
|
CoulFont( c ) ;
|
|
AffOneCar( pt->x, pt->y, pt->c, c ) ;
|
|
|
|
if ( c-StepDegrade/* >= */ <= MinDegrade ) c -= StepDegrade ;
|
|
else c = MinDegrade ;
|
|
}
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void CoulDial( LONG min, LONG max, LONG step )
|
|
{
|
|
MinDegrade = min ;
|
|
MaxDegrade = max ;
|
|
StepDegrade = step ;
|
|
NbDegrade = (((MaxDegrade-MinDegrade)+1)/StepDegrade) ;
|
|
}
|
|
|
|
void TestCoulDial( WORD coul )
|
|
{
|
|
MinDegrade = coul*16+12 ; // Loran
|
|
MaxDegrade = coul*16 ;
|
|
StepDegrade = -1 ;
|
|
NbDegrade = 14 ; // Loran
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
LONG GetText( LONG text )
|
|
{
|
|
UWORD offset0 ;
|
|
UWORD offset1 ;
|
|
LONG num ;
|
|
|
|
num = FindText( text ) ;/* Must have good number */
|
|
if ( num == -1 ) return(0L);
|
|
|
|
offset0 = *(UWORD*)(BufText+((num+0)*2L));
|
|
offset1 = *(UWORD*)(BufText+((num+1)*2L));
|
|
|
|
PtText = BufText+offset0 ;
|
|
|
|
SizeText = offset1-offset0 ;
|
|
|
|
return(1L) ;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void AffFleche()
|
|
{
|
|
TabPoly[0] = MinDegrade ;
|
|
TabPoly[1] = Dial_X1 - 3 ;
|
|
TabPoly[2] = Dial_Y1 - 24 ;
|
|
|
|
TabPoly[3] = MinDegrade ;
|
|
TabPoly[4] = Dial_X1 - 24 ;
|
|
TabPoly[5] = Dial_Y1 - 3 ;
|
|
|
|
TabPoly[6] = MaxDegrade ;
|
|
TabPoly[7] = Dial_X1 - 3 ;
|
|
TabPoly[8] = Dial_Y1 - 3 ;
|
|
|
|
TypePoly = 0 ;
|
|
NbPolyPoints = 3 ;
|
|
if( ComputePoly() )
|
|
FillVertic( TypePoly, MinDegrade ) ;
|
|
|
|
CopyBlockPhys( Dial_X1-24, Dial_Y1-24, Dial_X1-3, Dial_Y1-3 ) ;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void InitDialWindow()
|
|
{
|
|
CopyBlock( Dial_X0, Dial_Y0, Dial_X1, Dial_Y1, Screen,
|
|
Dial_X0, Dial_Y0, Log ) ;
|
|
|
|
// Fred message shade on/off
|
|
if( FlagMessageShade )
|
|
{
|
|
DrawCadre( Dial_X0, Dial_Y0, Dial_X1, Dial_Y1 ) ;
|
|
ShadeBox( Dial_X0+1, Dial_Y0+1, Dial_X1-1, Dial_Y1-1, 3 ) ;
|
|
}
|
|
CopyBlockPhys( Dial_X0, Dial_Y0, Dial_X1, Dial_Y1 ) ;
|
|
NbCar = 0 ;
|
|
CopyBlock( Dial_X0, Dial_Y0, Dial_X1, Dial_Y1, Log,
|
|
Dial_X0, Dial_Y0, Screen ) ;
|
|
// CopyScreen( Log, Screen ) ;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void SecondInitDialWindow()
|
|
{
|
|
CopyBlock( Dial_X0, Dial_Y0, Dial_X1, Dial_Y1, Screen,
|
|
Dial_X0, Dial_Y0, Log ) ;
|
|
|
|
CopyBlockPhys( Dial_X0, Dial_Y0, Dial_X1, Dial_Y1 ) ;
|
|
NbCar = 0 ;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void NormalWinDial()
|
|
{
|
|
Dial_X0 = 16 ;
|
|
Dial_Y0 = 334 ;
|
|
Dial_X1 = 639-16;
|
|
Dial_Y1 = 479-16;
|
|
|
|
MaxLineDial = 3 ;
|
|
DialMaxSize = ((Dial_X1-8)-(Dial_X0+8)) ;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void BigWinDial()
|
|
{
|
|
Dial_X0 = 8 ;
|
|
Dial_Y0 = 8 ;
|
|
Dial_X1 = 639-8 ;
|
|
Dial_Y1 = 479-8 ;
|
|
|
|
MaxLineDial = 11 ;
|
|
DialMaxSize = ((Dial_X1-8)-(Dial_X0+8)) ;
|
|
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
/*
|
|
void DefWinDial( LONG x0, LONG y0, LONG x1, LONG y1 )
|
|
{
|
|
WORD yh, yb ;
|
|
WORD xl, xr ;
|
|
|
|
Dial_X0 = x0 ;
|
|
Dial_Y0 = y0 ;
|
|
Dial_X1 = x1 ;
|
|
Dial_Y1 = y1 ;
|
|
|
|
xl = Dial_X0+8 ;
|
|
xr = Dial_X1-8 ;
|
|
yh = Dial_Y0+8 ;
|
|
yb = Dial_Y1-40 ;
|
|
|
|
DialMaxSize = ((Dial_X1-8)-(Dial_X0+8)) ;
|
|
MaxLineDial = (yb-yh)/36 ;
|
|
}
|
|
*/
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
void CommonOpenDial( LONG text )
|
|
{
|
|
CloseDial() ;
|
|
if ( !GetText( text )) return ;
|
|
CurrentDial = text ;
|
|
X_Dial = Dial_X0+8 ;
|
|
Y_Dial = Dial_Y0+8 ;
|
|
NbLineDial = 0 ;
|
|
PtDial = PtText ;
|
|
*Word = 0 ;
|
|
PtWord = Word ;
|
|
*BufLine = 0 ;
|
|
PtLine = BufLine ;
|
|
NbCar = 0 ;
|
|
FlagEndDial = FALSE ;
|
|
FlagEnd3Line = FALSE ;
|
|
FlagRunningDial = TRUE ;
|
|
|
|
SetFont( LbaFont, INTER_LEAVE, INTER_SPACE ) ;
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
void OpenDial(LONG text)
|
|
{
|
|
CommonOpenDial( text ) ;
|
|
|
|
InitDialWindow() ;
|
|
#ifdef LBA_EDITOR
|
|
if ( QuickMessage )
|
|
{
|
|
CoulText( JAUNE, -1 ) ;
|
|
Text( Dial_X0+2, Dial_Y0+2, "%FMess:%l ", text ) ;
|
|
}
|
|
#endif
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void OpenDialNoWindow(LONG text)
|
|
{
|
|
CommonOpenDial( text ) ;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void GetNextLine()
|
|
{
|
|
LONG dx, dd ;
|
|
LONG flag ;
|
|
|
|
SizeLine = 0 ;
|
|
NbSpace = 0 ;
|
|
*BufLine = 0 ;
|
|
SizeSpace = INTER_SPACE ;
|
|
flag = 1 ;// Justifie
|
|
|
|
while(TRUE)
|
|
{
|
|
while( *PtDial == ' ' ) PtDial++;
|
|
if ( *PtDial == 0 ) break ;
|
|
GetNextWord( PtDial, Word ) ;
|
|
if ( SizeLine+SizeSpace+SizeWord > DialMaxSize ) break ;
|
|
//------------- Caractere Spéciaux, saut de ligne, de page, etc.
|
|
if ( *PtDial == 1 )
|
|
{
|
|
PtDial++ ;
|
|
flag = 0 ;
|
|
break ;
|
|
}
|
|
if ( *Word == '@' )
|
|
{
|
|
flag = 0 ;
|
|
PtDial++ ;
|
|
if ( SizeLine == 0 )// Line Vide
|
|
{
|
|
strcpy( BufLine, " " ) ;
|
|
SizeLine = INTER_SPACE ;
|
|
}
|
|
if ( *(Word+1) == 'P' )
|
|
{
|
|
NbLineDial = MaxLineDial;
|
|
PtDial++ ;
|
|
}
|
|
break ;
|
|
}
|
|
//-------------
|
|
PtDial += LenWord ;
|
|
strcat( BufLine, Word ) ;
|
|
strcat( BufLine, " " ) ;
|
|
SizeLine += (SizeWord+SizeSpace);
|
|
NbSpace++ ;
|
|
if ( *PtDial == 0 ) break ;
|
|
PtDial++ ;
|
|
}
|
|
|
|
if ( NbSpace ) NbSpace-- ;// Ne doit jamais arrive :-]
|
|
|
|
if (( *PtDial != 0 ) // Derniere Ligne ou Ligne seule
|
|
AND ( flag == 1 )) // Pas tout le temps, c'est a c...
|
|
{
|
|
dx = DialMaxSize-SizeLine ;
|
|
dd = dx/NbSpace ;
|
|
SizeSpace += dd ;
|
|
dd = NbSpace*dd ;
|
|
NbBigSpace = dx-dd ;
|
|
}
|
|
|
|
LenLine = strlen(BufLine) ;
|
|
PtLine = BufLine ;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void InitEndPage()
|
|
{
|
|
LONG i ;
|
|
|
|
*BufLine = 0 ;
|
|
for ( i = 0 ; i < NbDegrade ; i++ )
|
|
strcat( BufLine, " ") ;
|
|
PtLine = BufLine ;
|
|
LenLine = NbDegrade ;
|
|
SizeLine = 16 ;// Bidon
|
|
NbLineDial = 0 ;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
LONG NextDialCar()
|
|
{
|
|
LONG dx, dy ;
|
|
|
|
if ( FlagRunningDial == FALSE ) return(0) ;
|
|
|
|
if ( *PtLine == 0 )
|
|
{
|
|
if ( FlagEndDial )
|
|
{
|
|
if( FlecheForcee )
|
|
{
|
|
AffFleche() ;
|
|
}
|
|
CloseDial() ;
|
|
FlagRunningDial = FALSE ;
|
|
return(0) ;// RETURN 0
|
|
}
|
|
if ( FlagEnd3Line )
|
|
{
|
|
SecondInitDialWindow() ;
|
|
FlagEnd3Line = FALSE ;
|
|
X_Dial = Dial_X0+8 ;
|
|
Y_Dial = Dial_Y0+8 ;
|
|
}
|
|
if ( *PtDial == 0 )
|
|
{
|
|
InitEndPage() ;
|
|
FlagEndDial = TRUE ;
|
|
return(1) ;// RETURN 1
|
|
}
|
|
|
|
GetNextLine() ;
|
|
|
|
}
|
|
|
|
if ( *PtLine != 0 )
|
|
{
|
|
PushCar( X_Dial, Y_Dial, *PtLine ) ;
|
|
AffAllCar() ;
|
|
GetDxDyMask( *PtLine, &dx, &dy, LbaFont );
|
|
|
|
if ( *PtLine != ' ' ) X_Dial += dx+INTER_LEAVE;
|
|
else
|
|
{
|
|
if ( NbBigSpace )
|
|
{
|
|
NbBigSpace-- ;
|
|
X_Dial++ ;
|
|
}
|
|
X_Dial += SizeSpace ;
|
|
}
|
|
|
|
PtLine++ ;
|
|
if ( *PtLine == 0 )
|
|
{
|
|
X_Dial = Dial_X0+8 ;
|
|
Y_Dial += INTER_LINE ;
|
|
|
|
if( ( FlagEnd3Line == TRUE )
|
|
AND (!FlagEndDial) )
|
|
{
|
|
AffFleche() ;
|
|
return(2) ;// RETURN 2
|
|
}
|
|
|
|
NbLineDial++ ;
|
|
if ( NbLineDial >= MaxLineDial )
|
|
{
|
|
InitEndPage() ;
|
|
FlagEnd3Line = TRUE ;
|
|
if ( *PtDial == 0 )
|
|
FlagEndDial = TRUE;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
return(1) ;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void CloseDial()
|
|
{
|
|
FlagRunningDial = FALSE ;
|
|
}
|
|
#ifdef CDROM
|
|
/*-------------------------------------------------------------------------*/
|
|
// D I A L C D R O M
|
|
/*-------------------------------------------------------------------------*/
|
|
void Dial( LONG text )
|
|
{
|
|
LONG ret = 0 ;
|
|
LONG flagabort=0;
|
|
|
|
|
|
MemoClip() ;
|
|
UnSetClip() ;
|
|
|
|
CopyScreen( Log, Screen ) ;
|
|
|
|
if ( FlagSpeak )
|
|
ret = Speak(text) ;
|
|
|
|
if (( !FlagDisplayText ) // Pas de texte et Voix OK
|
|
AND ( ret ))
|
|
{
|
|
while((TestSpeak()) AND ( Key != K_ESC )) ;
|
|
StopSpeak() ;
|
|
RestoreClip() ;
|
|
return ;
|
|
}
|
|
|
|
OpenDial( text );
|
|
|
|
while(TRUE)
|
|
{
|
|
ret = NextDialCar() ;
|
|
TestSpeak() ;
|
|
if ( ret == 2 ) /* Attente de Touche */
|
|
{
|
|
while(( Key )
|
|
OR ( Fire )
|
|
OR ( Joy )) TestSpeak() ;// Tu relaches ?
|
|
|
|
while(( !Key )
|
|
AND ( !Fire )
|
|
AND ( !Joy )) TestSpeak() ;// Tu appuies ?
|
|
}
|
|
|
|
if ( Key == K_ESC )// Player Abort...
|
|
{
|
|
flagabort = 1 ;
|
|
break ;
|
|
}
|
|
|
|
if ((( ret == 0 ) AND ( !TestSpeak()))// Tout fini
|
|
OR ( flagabort )) break ; // Ou Abort by player
|
|
}
|
|
|
|
StopSpeak() ;
|
|
CloseDial() ;
|
|
#ifndef LORAN
|
|
if(( ret == 0 ) AND ( !flagabort ))
|
|
{
|
|
while(!(( !Key ) AND ( !Fire ) AND ( !Joy ))) ;
|
|
|
|
while(( !Key ) AND ( !Fire ) AND ( !Joy )) ;
|
|
}
|
|
#endif
|
|
/*
|
|
if( FlagMessageShade )
|
|
while( Key == K_ESC ) ; // attente relachement que pour escape
|
|
// essai: ET que si il y a un cadre (ouf ouf)
|
|
*/
|
|
RestoreClip() ;
|
|
}
|
|
/*──────────────────────────────────────────────────────────────────────────*/
|
|
void MyDial( WORD nummess ) // attends une touche si autre page sinon continue
|
|
{
|
|
WORD dialstat = 1 ;
|
|
|
|
if ( FlagSpeak ) Speak(nummess) ;
|
|
|
|
OpenDial( nummess ) ;
|
|
|
|
while( dialstat )
|
|
{
|
|
dialstat = NextDialCar();
|
|
TestSpeak() ;
|
|
if( dialstat == 2 ) // encore 1 page
|
|
{
|
|
while( Key OR Fire OR Joy ) TestSpeak() ;
|
|
while( !Key AND !Fire AND !Joy ) TestSpeak() ;
|
|
}
|
|
}
|
|
|
|
while(TestSpeak()) ;// Wait until silence
|
|
|
|
StopSpeak() ;// Security
|
|
CloseDial() ;
|
|
}
|
|
#else
|
|
/*-------------------------------------------------------------------------*/
|
|
// D I A L N O C D
|
|
/*-------------------------------------------------------------------------*/
|
|
void Dial( LONG text )
|
|
{
|
|
LONG ret ;
|
|
|
|
MemoClip() ;
|
|
UnSetClip() ;
|
|
|
|
CopyScreen( Log, Screen ) ;
|
|
|
|
OpenDial( text );
|
|
|
|
while(TRUE)
|
|
{
|
|
ret = NextDialCar() ;
|
|
if ( ret == 2 ) /* Attente de Touche */
|
|
{
|
|
while(!(( !Key ) AND ( !Fire ) AND ( !Joy ))) ;
|
|
if ( Key == K_ESC ) break ;
|
|
while(( !Key ) AND ( !Fire ) AND ( !Joy )) ;
|
|
}
|
|
|
|
if (( ret == 0 ) OR ( Key == K_ESC )) break ;
|
|
}
|
|
CloseDial() ;
|
|
#ifndef LORAN
|
|
if( ret == 0 )
|
|
{
|
|
while(!(( !Key ) AND ( !Fire ) AND ( !Joy ))) ;
|
|
|
|
while(( !Key ) AND ( !Fire ) AND ( !Joy )) ;
|
|
}
|
|
#endif
|
|
/*
|
|
if( FlagMessageShade )
|
|
while( Key == K_ESC ) ; // attente relachement que pour escape
|
|
// essai: ET que si il y a un cadre (ouf ouf)
|
|
*/
|
|
RestoreClip() ;
|
|
}
|
|
/*──────────────────────────────────────────────────────────────────────────*/
|
|
|
|
void MyDial( WORD nummess ) // attends une touche si autre page sinon continue
|
|
{
|
|
WORD dialstat = 1 ;
|
|
|
|
OpenDial( nummess ) ;
|
|
|
|
while( dialstat )
|
|
{
|
|
dialstat = NextDialCar() ;
|
|
if( dialstat == 2 ) // encore 1 page
|
|
{
|
|
while( Key OR Fire OR Joy ) ;
|
|
while( !Key AND !Fire AND !Joy ) ;
|
|
}
|
|
}
|
|
|
|
CloseDial() ;
|
|
}
|
|
#endif
|
|
/*-------------------------------------------------------------------------*/
|
|
// attention size max ou tronquée à 255 car + 0
|
|
char *GetMultiText( LONG text, char *dst )
|
|
{
|
|
char *pts ;
|
|
char *ptd ;
|
|
LONG smax ;
|
|
|
|
if( (text == NumMultiText ) AND (Island == IslandMultiText) )
|
|
{
|
|
strcpy( dst, BufferMultiText ) ;
|
|
return dst ;
|
|
}
|
|
|
|
if ( !GetText( text ))
|
|
{
|
|
*dst = 0 ;
|
|
return 0L ;
|
|
}
|
|
|
|
pts = PtText ;
|
|
ptd = dst ;
|
|
|
|
smax = SizeText-1 ;
|
|
|
|
if( smax > 255 ) smax = 255 ;
|
|
|
|
MovMem( PtText, dst, smax ) ;
|
|
dst[smax] = 0 ;
|
|
|
|
MovMem( dst, BufferMultiText, smax+1 ) ;
|
|
NumMultiText = text ;
|
|
IslandMultiText = Island ;
|
|
|
|
return(dst) ;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
#ifdef LBA_EDITOR
|
|
void CleanMessage( UBYTE *string, LONG flag )
|
|
{
|
|
CopyScreen( Log, Screen ) ;
|
|
Message( string, flag ) ;
|
|
CopyScreen( Screen, Log ) ;
|
|
Flip() ;
|
|
}
|
|
#endif
|
|
/*-------------------------------------------------------------------------*/
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
|
|
|
|
|