1281 lines
26 KiB
C
1281 lines
26 KiB
C
#include "c_extern.h"
|
|
|
|
UBYTE *PtrPrg ;
|
|
|
|
// WORD OffsetLife ;
|
|
|
|
WORD TypeAnswer ;
|
|
|
|
WORD TextLig = 0 ;
|
|
|
|
extern WORD IndexGrm ;
|
|
extern WORD ZoneGrm ;
|
|
|
|
#define RET_BYTE 0
|
|
#define RET_WORD 1
|
|
#define RET_STRING 2
|
|
|
|
#ifdef CDROM
|
|
extern LONG FlagDisplayText ;
|
|
#endif
|
|
|
|
/*══════════════════════════════════════════════════════════════════════════*
|
|
█▀▀▀▄ █▀▀▀█ █ █ █▀▀▀▀ █▀▀▀▀
|
|
██ █ ██ █ ██ ██ ██▀▀ ██▀▀
|
|
▀▀▀▀ ▀▀▀▀▀ ▀▀▀▀▀ ▀▀▀▀▀ ▀▀ ▀▀ ▀▀▀▀▀
|
|
*══════════════════════════════════════════════════════════════════════════*/
|
|
/*──────────────────────────────────────────────────────────────────────────*/
|
|
|
|
void DoFuncLife( T_OBJET *ptrobj )
|
|
{
|
|
WORD num ;
|
|
WORD angle ;
|
|
LONG distance ;
|
|
|
|
TypeAnswer = RET_BYTE ;
|
|
|
|
switch( *PtrPrg++ ) /* func */
|
|
{
|
|
case LF_COL:
|
|
if( ptrobj->LifePoint <= 0 )
|
|
{
|
|
Value = -1 ;
|
|
}
|
|
else
|
|
{
|
|
Value = ptrobj->ObjCol ;
|
|
}
|
|
break ;
|
|
|
|
case LF_CHAPTER:
|
|
Value = Chapitre ;
|
|
break ;
|
|
|
|
case LF_LIFE_POINT:
|
|
Value = ptrobj->LifePoint ;
|
|
break ;
|
|
|
|
case LF_HIT_BY:
|
|
Value = ptrobj->HitBy ;
|
|
break ;
|
|
|
|
case LF_ACTION:
|
|
Value = ActionNormal ;
|
|
break ;
|
|
|
|
case LF_LIFE_POINT_OBJ:
|
|
Value = ListObjet[*PtrPrg++].LifePoint ;
|
|
break ;
|
|
|
|
case LF_COL_OBJ:
|
|
// Value = ListObjet[*PtrPrg++].ObjCol ;
|
|
num = *PtrPrg++ ;
|
|
if( ListObjet[num].LifePoint <= 0 )
|
|
{
|
|
Value = -1 ;
|
|
}
|
|
else
|
|
{
|
|
Value = ListObjet[num].ObjCol ;
|
|
}
|
|
break ;
|
|
|
|
case LF_DISTANCE:
|
|
num = (WORD)*PtrPrg++ ;
|
|
TypeAnswer = RET_WORD ;
|
|
|
|
if( ListObjet[num].WorkFlags & OBJ_DEAD )
|
|
{
|
|
Value = 32000 ;
|
|
break ;
|
|
}
|
|
|
|
if( abs(ListObjet[num].PosObjY-ptrobj->PosObjY) < 1500 )
|
|
{
|
|
distance = Distance2D( ptrobj->PosObjX,
|
|
ptrobj->PosObjZ,
|
|
ListObjet[num].PosObjX,
|
|
ListObjet[num].PosObjZ ) ;
|
|
if( distance > 32000 )
|
|
Value = 32000 ;
|
|
else
|
|
Value = distance ;
|
|
}
|
|
else
|
|
{
|
|
Value = 32000 ;
|
|
}
|
|
break ;
|
|
|
|
case LF_DISTANCE_3D:
|
|
num = (WORD)*PtrPrg++ ;
|
|
TypeAnswer = RET_WORD ;
|
|
|
|
if( ListObjet[num].WorkFlags & OBJ_DEAD )
|
|
{
|
|
Value = 32000 ;
|
|
break ;
|
|
}
|
|
|
|
distance = Distance3D( ptrobj->PosObjX,
|
|
ptrobj->PosObjY,
|
|
ptrobj->PosObjZ,
|
|
ListObjet[num].PosObjX,
|
|
ListObjet[num].PosObjY,
|
|
ListObjet[num].PosObjZ ) ;
|
|
|
|
if( distance > 32000 )
|
|
Value = 32000 ;
|
|
else
|
|
Value = distance ;
|
|
break ;
|
|
|
|
case LF_CONE_VIEW:
|
|
num = (WORD)*PtrPrg++ ;
|
|
TypeAnswer = RET_WORD ;
|
|
|
|
if( ListObjet[num].WorkFlags & OBJ_DEAD )
|
|
{
|
|
Value = 32000 ;
|
|
break ;
|
|
}
|
|
|
|
if( abs(ListObjet[num].PosObjY-ptrobj->PosObjY) < 1500 )
|
|
{
|
|
angle = GetAngle( ptrobj->PosObjX,
|
|
ptrobj->PosObjZ,
|
|
ListObjet[num].PosObjX,
|
|
ListObjet[num].PosObjZ ) ;
|
|
|
|
if( Distance > 32000 )
|
|
Distance = 32000 ;
|
|
}
|
|
else
|
|
{
|
|
Distance = 32000 ;
|
|
}
|
|
|
|
|
|
if( num == NUM_PERSO )
|
|
{
|
|
if( Comportement == C_DISCRET )
|
|
{
|
|
if( (((ptrobj->Beta + 1024 + 128) - (angle + 1024))&1023) <= 256 )
|
|
{
|
|
Value = Distance ;
|
|
}
|
|
else
|
|
{
|
|
Value = 32000 ;
|
|
}
|
|
}
|
|
else Value = Distance ;
|
|
}
|
|
else
|
|
{
|
|
if( (((ptrobj->Beta + 1024 + 128) - (angle + 1024))&1023) <= 256 )
|
|
{
|
|
Value = Distance ;
|
|
}
|
|
else
|
|
{
|
|
Value = 32000 ;
|
|
}
|
|
}
|
|
break ;
|
|
|
|
case LF_ZONE:
|
|
Value = ptrobj->ZoneSce ;
|
|
break ;
|
|
|
|
case LF_NB_GOLD_PIECES:
|
|
Value = NbGoldPieces ;
|
|
TypeAnswer = RET_WORD ;
|
|
break ;
|
|
|
|
case LF_NB_LITTLE_KEYS:
|
|
Value = NbLittleKeys ;
|
|
break ;
|
|
|
|
case LF_COMPORTEMENT_HERO:
|
|
Value = Comportement ;
|
|
break ;
|
|
|
|
case LF_MAGIC_LEVEL:
|
|
Value = MagicLevel ;
|
|
break ;
|
|
|
|
case LF_MAGIC_POINT:
|
|
Value = MagicPoint ;
|
|
break ;
|
|
|
|
case LF_CHOICE:
|
|
Value = GameChoice ;
|
|
TypeAnswer = RET_WORD ;
|
|
break ;
|
|
|
|
case LF_FUEL:
|
|
Value = Fuel ;
|
|
break ;
|
|
|
|
case LF_L_TRACK:
|
|
Value = ptrobj->LabelTrack ;
|
|
break ;
|
|
|
|
case LF_ZONE_OBJ:
|
|
Value = ListObjet[ *PtrPrg++ ].ZoneSce ;
|
|
break ;
|
|
|
|
case LF_FLAG_CUBE:
|
|
Value = ListFlagCube[ *PtrPrg++ ] ;
|
|
break ;
|
|
|
|
case LF_FLAG_GAME:
|
|
num = *PtrPrg++ ;
|
|
|
|
if( (ListFlagGame[FLAG_CONSIGNE] == 0)
|
|
OR (num >= MAX_INVENTORY) )
|
|
{ // si pas consigne ou pas inventaire
|
|
Value = ListFlagGame[ num ] ;
|
|
}
|
|
else // si flag consigne
|
|
{
|
|
if( num == FLAG_CONSIGNE )
|
|
{
|
|
Value = ListFlagGame[ num ] ;
|
|
}
|
|
else // ne possede aucun objet
|
|
{
|
|
Value = 0 ;
|
|
}
|
|
}
|
|
break ;
|
|
|
|
case LF_USE_INVENTORY:
|
|
num = *PtrPrg++ ; // flag game
|
|
|
|
if( num >= MAX_INVENTORY ) // a bon ?
|
|
{
|
|
Value = FALSE ;
|
|
}
|
|
|
|
if( ListFlagGame[FLAG_CONSIGNE] )
|
|
{
|
|
Value = 0 ;
|
|
}
|
|
else // si pas flag consigne
|
|
{
|
|
if( InventoryAction == num )
|
|
{ // action émise depuis l'inventaire à cette boucle
|
|
Value = TRUE ;
|
|
}
|
|
else
|
|
{
|
|
if( (ListFlagInventory[ num ] == 1)
|
|
AND (ListFlagGame[num] == 1) )
|
|
{
|
|
Value = TRUE ;
|
|
}
|
|
else
|
|
{
|
|
Value = FALSE ;
|
|
}
|
|
}
|
|
if( Value == TRUE )
|
|
{
|
|
// init incdisp symbol utilisation
|
|
InitIncrustDisp( INCRUST_OBJ,
|
|
num,
|
|
0, 0,
|
|
0, 0, 3 ) ;
|
|
}
|
|
}
|
|
break ;
|
|
|
|
case LF_L_TRACK_OBJ:
|
|
Value = ListObjet[ *PtrPrg++ ].LabelTrack ;
|
|
break ;
|
|
|
|
case LF_BODY:
|
|
Value = ptrobj->GenBody ;
|
|
break ;
|
|
|
|
case LF_BODY_OBJ:
|
|
Value = ListObjet[*PtrPrg++].GenBody ;
|
|
break ;
|
|
|
|
case LF_ANIM:
|
|
Value = ptrobj->GenAnim ;
|
|
break ;
|
|
|
|
case LF_ANIM_OBJ:
|
|
Value = ListObjet[*PtrPrg++].GenAnim ;
|
|
break ;
|
|
|
|
case LF_CARRY_BY:
|
|
Value = ptrobj->CarryBy ;
|
|
break ;
|
|
|
|
case LF_CDROM:
|
|
#ifdef CDROM
|
|
//Message( "CDROM TRUE" ) ;
|
|
Value = 1 ;
|
|
#else
|
|
//Message( "CDROM FALSE" ) ;
|
|
Value = 0 ;
|
|
#endif
|
|
break ;
|
|
|
|
}
|
|
}
|
|
|
|
/*──────────────────────────────────────────────────────────────────────────*/
|
|
|
|
WORD DoTest()
|
|
{
|
|
UBYTE test ;
|
|
WORD valueword ;
|
|
BYTE valuebyte ;
|
|
UBYTE *ptrstring ;
|
|
|
|
test = *PtrPrg++ ;
|
|
|
|
switch( TypeAnswer )
|
|
{
|
|
case RET_BYTE:
|
|
|
|
valuebyte = *PtrPrg++ ;
|
|
switch( test )
|
|
{
|
|
case LT_EQUAL:
|
|
return (Value == valuebyte) ;
|
|
|
|
case LT_SUP:
|
|
return (Value > valuebyte) ;
|
|
|
|
case LT_LESS:
|
|
return (Value < valuebyte) ;
|
|
|
|
case LT_SUP_EQUAL:
|
|
return (Value >= valuebyte) ;
|
|
|
|
case LT_LESS_EQUAL:
|
|
return (Value <= valuebyte) ;
|
|
|
|
case LT_DIFFERENT:
|
|
return (Value != valuebyte) ;
|
|
}
|
|
|
|
case RET_WORD:
|
|
|
|
valueword = *(WORD*)PtrPrg ;
|
|
PtrPrg += 2 ;
|
|
switch( test )
|
|
{
|
|
case LT_EQUAL:
|
|
return (Value == valueword) ;
|
|
|
|
case LT_SUP:
|
|
return (Value > valueword) ;
|
|
|
|
case LT_LESS:
|
|
return (Value < valueword) ;
|
|
|
|
case LT_SUP_EQUAL:
|
|
return (Value >= valueword) ;
|
|
|
|
case LT_LESS_EQUAL:
|
|
return (Value <= valueword) ;
|
|
|
|
case LT_DIFFERENT:
|
|
return (Value != valueword) ;
|
|
}
|
|
|
|
case RET_STRING:
|
|
|
|
valueword = stricmp( String, PtrPrg ) ;
|
|
PtrPrg += strlen( PtrPrg ) + 1 ;
|
|
|
|
switch( test )
|
|
{
|
|
case LT_EQUAL:
|
|
return (valueword == 0 ) ;
|
|
|
|
case LT_SUP:
|
|
case LT_LESS:
|
|
case LT_SUP_EQUAL:
|
|
case LT_LESS_EQUAL:
|
|
return FALSE ;
|
|
|
|
case LT_DIFFERENT:
|
|
return (valueword != 0 ) ;
|
|
}
|
|
}
|
|
return FALSE ;
|
|
}
|
|
|
|
/*──────────────────────────────────────────────────────────────────────────*/
|
|
|
|
|
|
void DoLife( WORD numobj )
|
|
{
|
|
WORD flag = 0 ;
|
|
UBYTE macro ;
|
|
T_OBJET *ptrobj ;
|
|
|
|
LONG obj ;
|
|
LONG num ;
|
|
UBYTE index ;
|
|
UBYTE *ptrmacro ;
|
|
LONG memoflagdisplaytext ;
|
|
LONG var ;
|
|
UBYTE string[256] ;
|
|
LONG dx, n ;
|
|
|
|
ptrobj = &ListObjet[numobj] ;
|
|
|
|
PtrPrg = ptrobj->PtrLife + ptrobj->OffsetLife ;
|
|
|
|
while( flag != -1 )
|
|
{
|
|
ptrmacro = PtrPrg ;
|
|
switch( *PtrPrg++ )
|
|
{
|
|
case LM_END:
|
|
case LM_END_LIFE:
|
|
ptrobj->OffsetLife = -1 ;
|
|
flag = -1 ;
|
|
break ;
|
|
|
|
case LM_RETURN:
|
|
case LM_END_COMPORTEMENT:
|
|
flag = -1 ;
|
|
break ;
|
|
|
|
case LM_LABEL:
|
|
case LM_COMPORTEMENT:
|
|
#ifdef LBA_EDITOR
|
|
if ( numobj == ObjSelected )/* TOOLS */
|
|
{
|
|
ComportementDebug = *PtrPrg ;
|
|
}
|
|
#endif
|
|
PtrPrg++ ;
|
|
break ;
|
|
|
|
case LM_FALLABLE:
|
|
num = *PtrPrg++ * OBJ_FALLABLE ;
|
|
ptrobj->Flags &= ~OBJ_FALLABLE ;
|
|
ptrobj->Flags |= num ;
|
|
break ;
|
|
|
|
case LM_COMPORTEMENT_HERO:
|
|
InitAnim( GEN_ANIM_RIEN, ANIM_REPEAT, NO_ANIM, NUM_PERSO ) ;
|
|
SetComportement( *PtrPrg++ ) ;
|
|
break ;
|
|
|
|
case LM_SET_MAGIC_LEVEL:
|
|
// si sce permet objets magique ordre quelconque transforme SET en INC
|
|
MagicLevel = *PtrPrg++ ;
|
|
// remplie magie a fond
|
|
MagicPoint = MagicLevel * 20 ;
|
|
break ;
|
|
|
|
case LM_SUB_MAGIC_POINT:
|
|
MagicPoint -= *PtrPrg++ ;
|
|
if( MagicPoint < 0 ) MagicPoint = 0 ;
|
|
break ;
|
|
|
|
case LM_CAM_FOLLOW:
|
|
num = *PtrPrg++ ;
|
|
if( num != NumObjFollow )
|
|
{
|
|
NumObjFollow = num ;
|
|
StartXCube = ((ListObjet[NumObjFollow].PosObjX+DEMI_BRICK_XZ)/SIZE_BRICK_XZ) ;
|
|
StartYCube = ((ListObjet[NumObjFollow].PosObjY+SIZE_BRICK_Y)/SIZE_BRICK_Y) ;
|
|
StartZCube = ((ListObjet[NumObjFollow].PosObjZ+DEMI_BRICK_XZ)/SIZE_BRICK_XZ) ;
|
|
FirstTime = TRUE ;
|
|
}
|
|
break ;
|
|
|
|
case LM_INIT_PINGOUIN:
|
|
num = *PtrPrg++ ;
|
|
NumPingouin = num ;
|
|
ListObjet[num].WorkFlags |= OBJ_DEAD ;
|
|
ListObjet[num].Body = -1 ;
|
|
ListObjet[num].ZoneSce = -1 ;
|
|
break ;
|
|
|
|
case LM_KILL_OBJ:
|
|
num = *PtrPrg++ ;
|
|
CheckCarrier( num ) ;
|
|
ListObjet[num].WorkFlags |= OBJ_DEAD ;
|
|
ListObjet[num].Body = -1 ;
|
|
ListObjet[num].ZoneSce = -1 ;
|
|
ListObjet[num].LifePoint = 0 ;
|
|
break ;
|
|
|
|
case LM_SUICIDE:
|
|
CheckCarrier( numobj ) ;
|
|
ptrobj->WorkFlags |= OBJ_DEAD ;
|
|
ptrobj->Body = -1 ;
|
|
ptrobj->ZoneSce = -1 ;
|
|
ptrobj->LifePoint = 0 ;
|
|
break ;
|
|
|
|
case LM_SET_DIR:
|
|
ptrobj->Move = *PtrPrg++ ;
|
|
if( ptrobj->Move == MOVE_FOLLOW )
|
|
{
|
|
ptrobj->Info3 = *PtrPrg++ ;
|
|
}
|
|
break ;
|
|
|
|
case LM_SET_DIR_OBJ:
|
|
obj = *PtrPrg++ ;
|
|
num = ListObjet[obj].Move = *PtrPrg++ ;
|
|
if( num == MOVE_FOLLOW )
|
|
{
|
|
ListObjet[obj].Info3 = *PtrPrg++ ;
|
|
}
|
|
break ;
|
|
|
|
case LM_SET_LIFE:
|
|
case LM_SET_COMPORTEMENT:
|
|
ptrobj->OffsetLife = *(WORD*)PtrPrg ;
|
|
PtrPrg += 2 ;
|
|
break ;
|
|
|
|
case LM_SET_LIFE_OBJ:
|
|
case LM_SET_COMPORTEMENT_OBJ:
|
|
num = *PtrPrg++ ;
|
|
ListObjet[num].OffsetLife = *(WORD*)PtrPrg ;
|
|
PtrPrg += 2 ;
|
|
break ;
|
|
|
|
case LM_SET_LIFE_POINT_OBJ:
|
|
num = *PtrPrg++ ;
|
|
ListObjet[num].LifePoint = *PtrPrg++ ;
|
|
break ;
|
|
|
|
case LM_SUB_LIFE_POINT_OBJ:
|
|
num = *PtrPrg++ ;
|
|
ListObjet[num].LifePoint -= *PtrPrg++ ;
|
|
if( ListObjet[num].LifePoint < 0 )
|
|
ListObjet[num].LifePoint = 0 ;
|
|
break ;
|
|
|
|
case LM_HIT_OBJ:
|
|
num = *PtrPrg++ ;
|
|
HitObj( numobj, num, *PtrPrg++, ListObjet[num].Beta ) ;
|
|
break ;
|
|
|
|
case LM_SET_TRACK:
|
|
ptrobj->OffsetTrack = *(WORD*)PtrPrg ;
|
|
PtrPrg += 2 ;
|
|
break ;
|
|
|
|
case LM_SET_TRACK_OBJ:
|
|
num = *PtrPrg++ ;
|
|
ListObjet[num].OffsetTrack = *(WORD*)PtrPrg ;
|
|
PtrPrg += 2 ;
|
|
break ;
|
|
|
|
case LM_STOP_L_TRACK:
|
|
ptrobj->MemoLabelTrack = ptrobj->OffsetLabelTrack ;
|
|
ptrobj->OffsetTrack = -1 ;
|
|
break ;
|
|
|
|
case LM_RESTORE_L_TRACK:
|
|
ptrobj->OffsetTrack = ptrobj->MemoLabelTrack ;
|
|
break ;
|
|
|
|
case LM_IF:
|
|
DoFuncLife( ptrobj ) ;
|
|
if( !DoTest() )
|
|
{
|
|
PtrPrg = ptrobj->PtrLife + *(WORD*)PtrPrg ;
|
|
}
|
|
else
|
|
{
|
|
PtrPrg += 2 ;
|
|
}
|
|
break ;
|
|
|
|
case LM_OR_IF:
|
|
DoFuncLife( ptrobj ) ;
|
|
if( DoTest() )
|
|
{
|
|
PtrPrg = ptrobj->PtrLife + *(WORD*)PtrPrg ;
|
|
}
|
|
else
|
|
{
|
|
PtrPrg += 2 ;
|
|
}
|
|
break ;
|
|
|
|
case LM_SWIF:
|
|
DoFuncLife( ptrobj ) ;
|
|
if( !DoTest() )
|
|
{
|
|
PtrPrg = ptrobj->PtrLife + *(WORD*)PtrPrg ;
|
|
}
|
|
else
|
|
{
|
|
*ptrmacro = LM_SNIF ;
|
|
PtrPrg += 2 ;
|
|
}
|
|
break ;
|
|
|
|
case LM_SNIF: /* swif inversé tjrs jump jusqu'a cond inverse */
|
|
DoFuncLife( ptrobj ) ;
|
|
if( !DoTest() )
|
|
{
|
|
*ptrmacro = LM_SWIF ;
|
|
}
|
|
PtrPrg = ptrobj->PtrLife + *(WORD*)PtrPrg ;
|
|
break ;
|
|
|
|
case LM_ONEIF:
|
|
DoFuncLife( ptrobj ) ;
|
|
if( !DoTest() )
|
|
{
|
|
PtrPrg = ptrobj->PtrLife + *(WORD*)PtrPrg ;
|
|
}
|
|
else
|
|
{
|
|
PtrPrg += 2 ;
|
|
*ptrmacro = LM_NEVERIF ;
|
|
}
|
|
break ;
|
|
|
|
case LM_NEVERIF:
|
|
DoFuncLife( ptrobj ) ;
|
|
DoTest() ;
|
|
PtrPrg = ptrobj->PtrLife + *(WORD*)PtrPrg ;
|
|
break ;
|
|
|
|
case LM_OFFSET: /* jmp à offset */
|
|
PtrPrg = ptrobj->PtrLife + *(WORD*)PtrPrg ;
|
|
break ;
|
|
|
|
case LM_ELSE:
|
|
PtrPrg = ptrobj->PtrLife + *(WORD*)PtrPrg ;
|
|
break ;
|
|
|
|
case LM_BODY:
|
|
InitBody( *PtrPrg++, numobj ) ;
|
|
break ;
|
|
|
|
case LM_BODY_OBJ:
|
|
num = *PtrPrg++ ;
|
|
InitBody( *PtrPrg++, num ) ;
|
|
break ;
|
|
|
|
case LM_ANIM_OBJ:
|
|
num = *PtrPrg++ ;
|
|
InitAnim( *PtrPrg++, ANIM_REPEAT,0, num ) ;
|
|
break ;
|
|
|
|
case LM_ANIM:
|
|
InitAnim( *PtrPrg++, ANIM_REPEAT,0,numobj ) ;
|
|
break ;
|
|
|
|
case LM_ANIM_SET:
|
|
ptrobj->GenAnim = NO_ANIM ;
|
|
ptrobj->Anim = -1 ;
|
|
InitAnim( *PtrPrg++, ANIM_REPEAT,0,numobj ) ;
|
|
break ;
|
|
|
|
case LM_MESSAGE_OBJ:
|
|
SaveTimer() ;
|
|
TestRestoreModeSVGA( TRUE ) ;
|
|
num = *PtrPrg++ ;
|
|
if( Bulle ) DrawBulle( num ) ;
|
|
TestCoulDial( ListObjet[num].CoulObj ) ;
|
|
#ifdef CDROM
|
|
NumObjSpeak = num ;
|
|
#endif
|
|
Dial( *(WORD*)PtrPrg ) ;
|
|
PtrPrg += 2 ;
|
|
RestoreTimer() ;
|
|
|
|
AffScene(TRUE) ;
|
|
WaitReleaseSpace() ;
|
|
break ;
|
|
|
|
case LM_MESSAGE:
|
|
SaveTimer() ;
|
|
TestRestoreModeSVGA( TRUE ) ;
|
|
if( Bulle ) DrawBulle( numobj ) ;
|
|
TestCoulDial( ptrobj->CoulObj ) ;
|
|
#ifdef CDROM
|
|
NumObjSpeak = numobj ;
|
|
#endif
|
|
Dial( *(WORD*)PtrPrg ) ;
|
|
PtrPrg += 2 ;
|
|
RestoreTimer() ;
|
|
AffScene(TRUE) ;
|
|
WaitReleaseSpace() ;
|
|
break ;
|
|
|
|
case LM_SAY_MESSAGE_OBJ:
|
|
obj = *PtrPrg++ ;
|
|
num = *(WORD*)PtrPrg ;
|
|
InitIncrustDisp( INCRUST_TEXT,
|
|
num,
|
|
0, 0,
|
|
obj, 1, 2 ) ;
|
|
PtrPrg += 2 ;
|
|
#ifdef CDROM
|
|
SaveTimer() ;
|
|
Speak( num ) ;
|
|
RestoreTimer() ;
|
|
#endif
|
|
break ;
|
|
|
|
case LM_SAY_MESSAGE:
|
|
num = *(WORD*)PtrPrg ;
|
|
InitIncrustDisp( INCRUST_TEXT,
|
|
num,
|
|
0, 0,
|
|
numobj, 1, 2 ) ;
|
|
PtrPrg += 2 ;
|
|
#ifdef CDROM
|
|
SaveTimer() ;
|
|
Speak( num ) ;
|
|
RestoreTimer() ;
|
|
#endif
|
|
break ;
|
|
|
|
case LM_SET_FLAG_CUBE:
|
|
num = *PtrPrg++ ;
|
|
ListFlagCube[num] = *PtrPrg++ ;
|
|
break ;
|
|
|
|
case LM_SET_FLAG_GAME:
|
|
num = *PtrPrg++ ;
|
|
ListFlagGame[num] = *PtrPrg++ ;
|
|
|
|
//Text( 0,100, "%Fset ListFlagGame %d = %d",num,ListFlagGame[num] ) ;
|
|
|
|
break ;
|
|
|
|
case LM_SET_USED_INVENTORY:
|
|
num = *PtrPrg++ ;
|
|
if( num < 24 )
|
|
ListFlagInventory[num] = TRUE ;
|
|
break ;
|
|
|
|
case LM_GIVE_GOLD_PIECES:
|
|
num = NbGoldPieces ;
|
|
NbGoldPieces -= *(WORD*)PtrPrg ;
|
|
if( NbGoldPieces < 0 )
|
|
{
|
|
NbGoldPieces = 0 ;
|
|
}
|
|
PtrPrg += 2 ;
|
|
|
|
// sample cling cling
|
|
// HQ_MixSample( 83, 0x1000, 2, 128, 128 ) ;
|
|
|
|
// aff piece
|
|
InitIncrustDisp( INCRUST_SPRITE,
|
|
3,
|
|
10, 15,
|
|
0, 0, 3 ) ;
|
|
|
|
// aff cmpt si pas
|
|
{
|
|
// attention MAGOUILLE
|
|
// ne marche que parcequ'il y n'y a
|
|
// qu'UN seul incrust_cmpt dans le jeu
|
|
|
|
T_INCRUST_DISP *ptrdisp ;
|
|
ptrdisp = ListIncrustDisp ;
|
|
var = 0 ;
|
|
for( n=0; n<MAX_INCRUST_DISP; n++, ptrdisp++ )
|
|
{
|
|
if( ptrdisp->Num == -1 )
|
|
continue ;
|
|
|
|
if( ptrdisp->Type==INCRUST_CMPT )
|
|
{
|
|
ptrdisp->Num = BoundRegleTrois( ptrdisp->Info, ptrdisp->Num, 50*2, ptrdisp->TimerEnd-TimerRef-50 ) ;
|
|
ptrdisp->Info = NbGoldPieces ;
|
|
ptrdisp->TimerEnd = TimerRef + 50 * 3 ;
|
|
var = 1 ;
|
|
break ;
|
|
}
|
|
}
|
|
|
|
if( !var ) // yen avait pas
|
|
{
|
|
InitIncrustDisp( INCRUST_CMPT,
|
|
num,
|
|
30, 20,
|
|
NbGoldPieces, 0, 3 ) ;
|
|
}
|
|
}
|
|
break ;
|
|
|
|
case LM_USE_ONE_LITTLE_KEY:
|
|
NbLittleKeys-- ;
|
|
if( NbLittleKeys < 0 ) NbLittleKeys = 0 ;
|
|
// affiche little key
|
|
InitIncrustDisp( INCRUST_SPRITE,
|
|
6,
|
|
0, 0,
|
|
NUM_PERSO, 1, 1 ) ;
|
|
break ;
|
|
|
|
case LM_INC_CHAPTER:
|
|
Chapitre++ ;
|
|
break ;
|
|
|
|
case LM_FOUND_OBJECT:
|
|
SaveTimer() ;
|
|
TestRestoreModeSVGA( TRUE ) ;
|
|
DoFoundObj( *PtrPrg++ ) ;
|
|
RestoreTimer() ;
|
|
AffScene( TRUE ) ;
|
|
break ;
|
|
|
|
case LM_SET_DOOR_LEFT:
|
|
ptrobj->Beta = 768 ;
|
|
ptrobj->PosObjX = ptrobj->AnimStepX - *(WORD*)PtrPrg ;
|
|
ptrobj->WorkFlags &= ~AUTO_STOP_DOOR ;
|
|
ptrobj->SRot = 0 ;
|
|
PtrPrg += 2 ;
|
|
break ;
|
|
|
|
case LM_SET_DOOR_RIGHT:
|
|
ptrobj->Beta = 256 ;
|
|
ptrobj->PosObjX = ptrobj->AnimStepX + *(WORD*)PtrPrg ;
|
|
ptrobj->WorkFlags &= ~AUTO_STOP_DOOR ;
|
|
ptrobj->SRot = 0 ;
|
|
PtrPrg += 2 ;
|
|
break ;
|
|
|
|
case LM_SET_DOOR_UP:
|
|
ptrobj->Beta = 512 ;
|
|
ptrobj->PosObjZ = ptrobj->AnimStepZ - *(WORD*)PtrPrg ;
|
|
ptrobj->WorkFlags &= ~AUTO_STOP_DOOR ;
|
|
ptrobj->SRot = 0 ;
|
|
PtrPrg += 2 ;
|
|
break ;
|
|
|
|
case LM_SET_DOOR_DOWN:
|
|
ptrobj->Beta = 0 ;
|
|
ptrobj->PosObjZ = ptrobj->AnimStepZ + *(WORD*)PtrPrg ;
|
|
ptrobj->WorkFlags &= ~AUTO_STOP_DOOR ;
|
|
ptrobj->SRot = 0 ;
|
|
PtrPrg += 2 ;
|
|
break ;
|
|
|
|
case LM_GIVE_BONUS:
|
|
if( ptrobj->OptionFlags & EXTRA_MASK )
|
|
{
|
|
GiveExtraBonus( ptrobj ) ;
|
|
|
|
}
|
|
if( *PtrPrg++ )
|
|
{
|
|
// ne donne plus rien ????
|
|
ptrobj->OptionFlags |= EXTRA_GIVE_NOTHING ;
|
|
}
|
|
break ;
|
|
|
|
case LM_CHANGE_CUBE:
|
|
NewCube = *PtrPrg++ ;
|
|
FlagChgCube = 2 ;
|
|
break ;
|
|
|
|
case LM_PLAY_MIDI:
|
|
PlayMusic( *PtrPrg++ ) ;
|
|
break ;
|
|
|
|
case LM_ADD_FUEL:
|
|
Fuel += *PtrPrg++ ;
|
|
if( Fuel > 100 ) Fuel = 100 ;
|
|
break ;
|
|
|
|
case LM_SUB_FUEL:
|
|
Fuel -= *PtrPrg++ ;
|
|
if( Fuel < 0 ) Fuel = 0 ;
|
|
break ;
|
|
|
|
case LM_SET_HOLO_POS:
|
|
SetHoloPos( *PtrPrg++ ) ;
|
|
if( ListFlagGame[FLAG_HOLOMAP] )
|
|
{
|
|
InitIncrustDisp( INCRUST_OBJ,
|
|
0, // holomap
|
|
0, 0,
|
|
0, 0, 3 ) ;
|
|
}
|
|
break ;
|
|
|
|
case LM_CLR_HOLO_POS:
|
|
ClrHoloPos( *PtrPrg++ ) ;
|
|
break ;
|
|
|
|
case LM_SET_GRM: // ne marche que si pas autre grm
|
|
IncrustGrm( (IndexGrm = *PtrPrg++) ) ;
|
|
break ;
|
|
|
|
case LM_INC_CLOVER_BOX:
|
|
if( NbCloverBox < MAX_CLOVER_BOX )
|
|
{
|
|
NbCloverBox++ ;
|
|
}
|
|
break ;
|
|
|
|
case LM_OBJ_COL:
|
|
if( *PtrPrg++ ) ptrobj->Flags |= CHECK_OBJ_COL ;
|
|
else ptrobj->Flags &= ~CHECK_OBJ_COL ;
|
|
break ;
|
|
|
|
case LM_INVISIBLE:
|
|
if( *PtrPrg++ ) ptrobj->Flags |= INVISIBLE ;
|
|
else ptrobj->Flags &= ~INVISIBLE ;
|
|
break ;
|
|
|
|
case LM_BRICK_COL:
|
|
num = *PtrPrg++ ;
|
|
ptrobj->Flags &= ~(CHECK_BRICK_COL+COL_BASSE) ;
|
|
if( num == 1 )
|
|
{
|
|
ptrobj->Flags &= ~(CHECK_BRICK_COL+COL_BASSE) ;
|
|
ptrobj->Flags |= CHECK_BRICK_COL ;
|
|
}
|
|
if( num == 2 )
|
|
{
|
|
ptrobj->Flags |= CHECK_BRICK_COL+COL_BASSE ;
|
|
}
|
|
break ;
|
|
|
|
case LM_ZOOM:
|
|
if( *PtrPrg++ )
|
|
{
|
|
if( (!FlagMCGA) AND (SceZoom!=0) )
|
|
{
|
|
FadeToBlack( PtrPal ) ;
|
|
ExtInitMcga() ;
|
|
SetBlackPal() ;
|
|
FlagFade = TRUE ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( FlagMCGA )
|
|
{
|
|
FadeToBlack( PtrPal ) ;
|
|
ExtInitSvga() ;
|
|
SetBlackPal() ;
|
|
FlagFade = TRUE ;
|
|
FirstTime = TRUE ;
|
|
}
|
|
}
|
|
break ;
|
|
|
|
case LM_POS_POINT:
|
|
Value = *PtrPrg++ ; // index point
|
|
X0 = ListBrickTrack[Value].X ;
|
|
Y0 = ListBrickTrack[Value].Y ;
|
|
Z0 = ListBrickTrack[Value].Z ;
|
|
|
|
ptrobj->PosObjX = X0 ;
|
|
ptrobj->PosObjY = Y0 ;
|
|
ptrobj->PosObjZ = Z0 ;
|
|
break ;
|
|
|
|
case LM_PLAY_FLA:
|
|
SaveTimer() ;
|
|
if( FlagPalettePcx ) FadeToBlack( PalettePcx ) ;
|
|
else FadeToBlack( PtrPal ) ;
|
|
HQ_StopSample() ;
|
|
PlayAnimFla( PtrPrg ) ;
|
|
PtrPrg += strlen( PtrPrg ) + 1 ;
|
|
RestoreTimer() ;
|
|
FlagFade = TRUE ;
|
|
FirstTime = TRUE ;
|
|
break ;
|
|
|
|
case LM_ADD_CHOICE:
|
|
GameListChoice[GameNbChoices] = *(WORD*)PtrPrg ;
|
|
PtrPrg += 2 ;
|
|
GameNbChoices++ ;
|
|
break ;
|
|
|
|
case LM_ASK_CHOICE:
|
|
#ifndef DEMO
|
|
SaveTimer() ;
|
|
TestRestoreModeSVGA( TRUE ) ;
|
|
if( Bulle ) DrawBulle( numobj ) ;
|
|
TestCoulDial( ptrobj->CoulObj ) ;
|
|
GameAskChoice( *(WORD*)PtrPrg ) ;
|
|
GameNbChoices = 0 ;
|
|
PtrPrg += 2 ;
|
|
// FlagFade = TRUE ;
|
|
RestoreTimer() ;
|
|
AffScene(TRUE) ;
|
|
WaitReleaseSpace() ;
|
|
#endif
|
|
break ;
|
|
|
|
case LM_ASK_CHOICE_OBJ:
|
|
#ifndef DEMO
|
|
SaveTimer() ;
|
|
num = *PtrPrg++ ;
|
|
TestRestoreModeSVGA( TRUE ) ;
|
|
if( Bulle ) DrawBulle( num ) ;
|
|
TestCoulDial( ListObjet[num].CoulObj ) ;
|
|
GameAskChoice( *(WORD*)PtrPrg ) ;
|
|
GameNbChoices = 0 ;
|
|
PtrPrg += 2 ;
|
|
// FlagFade = TRUE ;
|
|
RestoreTimer() ;
|
|
AffScene(TRUE) ;
|
|
WaitReleaseSpace() ;
|
|
#endif
|
|
break ;
|
|
|
|
case LM_BIG_MESSAGE:
|
|
SaveTimer() ;
|
|
TestRestoreModeSVGA( TRUE ) ;
|
|
BigWinDial() ;
|
|
if( Bulle ) DrawBulle( numobj ) ;
|
|
TestCoulDial( ptrobj->CoulObj ) ;
|
|
#ifdef CDROM
|
|
NumObjSpeak = numobj ;
|
|
#endif
|
|
Dial( *(WORD*)PtrPrg ) ;
|
|
PtrPrg += 2 ;
|
|
NormalWinDial() ;
|
|
AffScene(TRUE) ;
|
|
RestoreTimer() ;
|
|
WaitReleaseSpace() ;
|
|
break ;
|
|
|
|
case LM_FULL_POINT:
|
|
ListObjet[NUM_PERSO].LifePoint = 50 ;
|
|
MagicPoint = MagicLevel * 20 ;
|
|
break ;
|
|
|
|
case LM_BETA:
|
|
ptrobj->Beta = *(WORD*)PtrPrg ;
|
|
ClearRealAngle( ptrobj ) ;
|
|
PtrPrg += 2 ;
|
|
break ;
|
|
|
|
case LM_GRM_OFF:
|
|
if( IndexGrm != -1 )
|
|
{
|
|
IndexGrm = ZoneGrm = -1 ;
|
|
CopyMapToCube() ;
|
|
AffScene( TRUE ) ;
|
|
}
|
|
break ;
|
|
|
|
case LM_FADE_PAL_RED:
|
|
SaveTimer() ;
|
|
FadeToRed( PtrPal ) ;
|
|
FlagPalettePcx = FALSE ;
|
|
RestoreTimer() ;
|
|
break ;
|
|
|
|
case LM_FADE_ALARM_RED:
|
|
SaveTimer() ;
|
|
Load_HQR( PATH_RESSOURCE"ress.hqr", PalettePcx, RESS_PAL_ALARM ) ;
|
|
FadeToRed( PalettePcx ) ;
|
|
FlagPalettePcx = TRUE ;
|
|
RestoreTimer() ;
|
|
break ;
|
|
|
|
case LM_FADE_ALARM_PAL:
|
|
SaveTimer() ;
|
|
Load_HQR( PATH_RESSOURCE"ress.hqr", PalettePcx, RESS_PAL_ALARM ) ;
|
|
FadePalToPal( PalettePcx, PtrPal ) ;
|
|
FlagPalettePcx = FALSE ;
|
|
RestoreTimer() ;
|
|
break ;
|
|
|
|
case LM_FADE_RED_PAL:
|
|
SaveTimer() ;
|
|
FadeRedToPal( PtrPal ) ;
|
|
FlagPalettePcx = FALSE ;
|
|
RestoreTimer() ;
|
|
break ;
|
|
|
|
case LM_FADE_RED_ALARM:
|
|
SaveTimer() ;
|
|
Load_HQR( PATH_RESSOURCE"ress.hqr", PalettePcx, RESS_PAL_ALARM ) ;
|
|
FadeRedToPal( PalettePcx ) ;
|
|
FlagPalettePcx = TRUE ;
|
|
RestoreTimer() ;
|
|
break ;
|
|
|
|
case LM_FADE_PAL_ALARM:
|
|
SaveTimer() ;
|
|
Load_HQR( PATH_RESSOURCE"ress.hqr", PalettePcx, RESS_PAL_ALARM ) ;
|
|
FadePalToPal( PtrPal, PalettePcx ) ;
|
|
FlagPalettePcx = TRUE ;
|
|
RestoreTimer() ;
|
|
break ;
|
|
|
|
case LM_EXPLODE_OBJ:
|
|
num = *PtrPrg++ ;
|
|
ExtraExplo(
|
|
ListObjet[num].PosObjX + Rnd( 512 ) - 256 ,
|
|
ListObjet[num].PosObjY + Rnd( 256 ) - 128 ,
|
|
ListObjet[num].PosObjZ + Rnd( 512 ) - 256 ) ;
|
|
break;
|
|
|
|
case LM_BULLE_ON:
|
|
Bulle = TRUE ;
|
|
break ;
|
|
|
|
case LM_BULLE_OFF:
|
|
Bulle = FALSE ;
|
|
break ;
|
|
|
|
case LM_SET_DARK_PAL:
|
|
SaveTimer() ;
|
|
Load_HQR( PATH_RESSOURCE"ress.hqr", PalettePcx, RESS_PAL_MUSEE ) ;
|
|
if( !FlagFade ) Palette( PalettePcx ) ;
|
|
FlagPalettePcx = TRUE ;
|
|
RestoreTimer() ;
|
|
break ;
|
|
|
|
case LM_SET_NORMAL_PAL:
|
|
FlagPalettePcx = FALSE ;
|
|
if( !FlagFade ) Palette( PtrPal ) ;
|
|
break ;
|
|
|
|
case LM_MESSAGE_SENDELL:
|
|
#ifndef DEMO
|
|
SaveTimer() ;
|
|
TestRestoreModeSVGA( TRUE ) ;
|
|
|
|
FadeToBlack( PtrPal ) ;
|
|
Load_HQR( PATH_RESSOURCE"ress.hqr", Screen, RESS_SENDELL_PCR ) ;
|
|
CopyScreen( Screen, Log ) ;
|
|
Load_HQR( PATH_RESSOURCE"ress.hqr", PalettePcx, RESS_SENDELL_PAL ) ;
|
|
Flip() ;
|
|
FadeToPal( PalettePcx ) ;
|
|
|
|
BigWinDial() ;
|
|
TestCoulDial( 15 ) ;
|
|
#ifdef CDROM
|
|
memoflagdisplaytext = FlagDisplayText ;
|
|
FlagDisplayText = TRUE ;
|
|
#endif
|
|
FlagMessageShade = FALSE ;
|
|
Dial( 6 ) ;
|
|
FlagMessageShade = TRUE ;
|
|
|
|
NormalWinDial() ;
|
|
FadeToBlack( PalettePcx ) ;
|
|
Cls() ;
|
|
Flip();
|
|
Palette( PtrPal ) ;
|
|
#ifdef CDROM
|
|
FlagDisplayText = memoflagdisplaytext ;
|
|
#endif
|
|
while( (Fire & F_SPACE)
|
|
OR (Key == K_ESC) ) ;
|
|
RestoreTimer() ;
|
|
#endif
|
|
break ;
|
|
|
|
case LM_HOLOMAP_TRAJ:
|
|
NumHolomapTraj = *PtrPrg++ ; // signal pour chg cube
|
|
break ;
|
|
|
|
case LM_GAME_OVER:
|
|
ListObjet[NUM_PERSO].LifePoint = 0 ;
|
|
ListObjet[NUM_PERSO].WorkFlags |= ANIM_END ;
|
|
NbFourLeafClover = 0 ;
|
|
flag = -1 ;
|
|
break ;
|
|
|
|
case LM_THE_END:
|
|
#ifndef DEMO
|
|
// Save Partie retour scene de fin (inrejouable ?)
|
|
NbFourLeafClover = 0 ;
|
|
ListObjet[NUM_PERSO].LifePoint = 50 ;
|
|
MagicPoint = 80 ;
|
|
Comportement = SaveComportement ;
|
|
ListObjet[NUM_PERSO].Beta = SaveBeta ;
|
|
NumCube = 113 ;
|
|
SceneStartX = -1 ;
|
|
SaveGame() ;
|
|
FlagTheEnd = 1 ; // credits
|
|
flag = -1 ;
|
|
#endif
|
|
break ;
|
|
|
|
case LM_BRUTAL_EXIT:
|
|
FlagTheEnd = 0 ;
|
|
flag = -1 ;
|
|
break ;
|
|
|
|
case LM_MIDI_OFF:
|
|
StopMusicMidi() ;
|
|
break ;
|
|
|
|
case LM_PLAY_CD_TRACK:
|
|
#ifdef CDROM
|
|
PlayCdTrack( *PtrPrg++ ) ;
|
|
#else
|
|
PtrPrg++ ;
|
|
#endif
|
|
break ;
|
|
|
|
case LM_PROJ_ISO:
|
|
SetIsoProjection( 320-8-1, 240, SIZE_BRICK_XZ ) ;
|
|
SetPosCamera( 0,0,0 ) ;
|
|
SetAngleCamera( 0,0,0 ) ;
|
|
SetLightVector( AlphaLight, BetaLight, 0 ) ;
|
|
break ;
|
|
|
|
case LM_PROJ_3D:
|
|
Cls() ;
|
|
CopyScreen( Log, Screen ) ;
|
|
Flip() ;
|
|
FlagAffGrille = FALSE ;
|
|
SetProjection( 320, 240, 128,1024,1024 ) ;
|
|
SetFollowCamera( 0,1500,0, 25,-128,0, 13000 ) ;
|
|
SetLightVector( 896, 950, 0 ) ;
|
|
InitDial( 1 ) ;
|
|
break ;
|
|
|
|
case LM_TEXT:
|
|
if( TextLig < 440 )
|
|
{
|
|
num = *(WORD*)PtrPrg ;
|
|
if( !Version_US )
|
|
{
|
|
if( num == 0 ) num = 16 ;
|
|
}
|
|
GetMultiText( num, string ) ;
|
|
PtrPrg += 2 ;
|
|
dx = SizeFont( string ) ;
|
|
CoulFont( 15 ) ;
|
|
Font( 0, TextLig, string ) ;
|
|
if( dx > 639 ) dx = 639 ;
|
|
CopyBlockPhys( 0, TextLig, dx, TextLig+40 ) ;
|
|
TextLig += 40 ;
|
|
}
|
|
break ;
|
|
|
|
case LM_CLEAR_TEXT:
|
|
TextLig = 0 ;
|
|
Box( 0,0, 639, 40*6, 0 ) ;
|
|
CopyBlockPhys( 0,0, 639, 40*6 ) ;
|
|
break ;
|
|
}
|
|
}
|
|
}
|