mirror of
https://github.com/blupi-games/planetblupi
synced 2024-12-30 10:15:36 +01:00
5345 lines
98 KiB
C++
5345 lines
98 KiB
C++
// Event.cpp
|
|
//
|
|
|
|
#include <windows.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <ddraw.h>
|
|
#include "def.h"
|
|
#include "resource.h"
|
|
#include "pixmap.h"
|
|
#include "sound.h"
|
|
#include "decor.h"
|
|
#include "movie.h"
|
|
#include "button.h"
|
|
#include "menu.h"
|
|
#include "jauge.h"
|
|
#include "event.h"
|
|
#include "action.h"
|
|
#include "text.h"
|
|
#include "misc.h"
|
|
|
|
|
|
#define DEF_TIME_HELP 10000 // ~10 minutes
|
|
#define DEF_TIME_DEMO 1000 // ~1 minute
|
|
#define MAXDEMO 2000
|
|
|
|
|
|
typedef struct
|
|
{
|
|
short majRev;
|
|
short minRev;
|
|
short reserve1[9];
|
|
short exercice; // exercice en cours (0..n)
|
|
short mission; // mission en cours (0..n)
|
|
short speed;
|
|
short bMovie;
|
|
short maxMission; // dernière mission effectuée (0..n)
|
|
short scrollSpeed;
|
|
short audioVolume;
|
|
short midiVolume;
|
|
short bAccessBuild;
|
|
short prive;
|
|
short skill;
|
|
short reserve2[93];
|
|
}
|
|
DescInfo;
|
|
|
|
|
|
|
|
// Toutes les premières lettres doivent
|
|
// être différentes !
|
|
|
|
static char cheat_code[9][20] =
|
|
{
|
|
"VISION", // 0
|
|
"POWER", // 1
|
|
"LONESOME", // 2
|
|
"ALLMISSIONS", // 3
|
|
"QUICK", // 4
|
|
"HELPME", // 5
|
|
"INVINCIBLE", // 6
|
|
"SUPERBLUPI", // 7
|
|
"CONSTRUIRE", // 8 (CPOTUSVJSF)
|
|
};
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
static Phase table[] =
|
|
{
|
|
{
|
|
WM_PHASE_TESTCD,
|
|
"image\\init.blp",
|
|
FALSE,
|
|
{
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_INTRO1,
|
|
"image\\intro1.blp",
|
|
FALSE,
|
|
{
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_INTRO2,
|
|
"image\\intro2.blp",
|
|
FALSE,
|
|
{
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_INIT,
|
|
"image\\init.blp",
|
|
FALSE,
|
|
{
|
|
{
|
|
WM_PHASE_DEMO,
|
|
0, {1,108},
|
|
16, 424-60-42*3-18,
|
|
{1,TX_BUTTON_DEMO},
|
|
},
|
|
{
|
|
WM_PHASE_SCHOOL,
|
|
0, {1,79},
|
|
16, 424-60-42*2,
|
|
{1,TX_BUTTON_APPRENDRE},
|
|
},
|
|
{
|
|
WM_PHASE_MISSION,
|
|
0, {1,80},
|
|
16, 424-60-42*1,
|
|
{1,TX_BUTTON_JOUER},
|
|
},
|
|
#if !_DEMO
|
|
{
|
|
WM_PHASE_PRIVATE,
|
|
0, {1,49},
|
|
16, 424-60-42*0,
|
|
{1,TX_BUTTON_PRIVE},
|
|
},
|
|
#endif
|
|
{
|
|
WM_PHASE_BYE,
|
|
//? WM_CLOSE,
|
|
0, {1,36},
|
|
16, 424,
|
|
{1,TX_BUTTON_QUITTER},
|
|
},
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_HISTORY0,
|
|
"image\\history0.blp",
|
|
TRUE,
|
|
{
|
|
{
|
|
WM_PHASE_INIT,
|
|
0, {1,50},
|
|
42+42*0, 433,
|
|
{1,TX_BUTTON_PREVH},
|
|
},
|
|
{
|
|
WM_PHASE_H1MOVIE,
|
|
0, {1,51},
|
|
558-42*0, 433,
|
|
{1,TX_BUTTON_NEXTH},
|
|
},
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_HISTORY1,
|
|
"image\\history1.blp",
|
|
TRUE,
|
|
{
|
|
{
|
|
WM_PHASE_HISTORY0,
|
|
0, {1,50},
|
|
42+42*0, 433,
|
|
{1,TX_BUTTON_PREVH},
|
|
},
|
|
{
|
|
WM_PHASE_H2MOVIE,
|
|
0, {1,51},
|
|
558-42*0, 433,
|
|
{1,TX_BUTTON_NEXTH},
|
|
},
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_INFO,
|
|
"image\\info%.3d.blp",
|
|
FALSE,
|
|
{
|
|
{
|
|
WM_PREV,
|
|
0, {1,50},
|
|
558-42*2, 433,
|
|
{1,TX_BUTTON_PREVP},
|
|
},
|
|
{
|
|
WM_PHASE_PLAYMOVIE,
|
|
0, {1,48},
|
|
558-42*1, 433,
|
|
{1,TX_BUTTON_PLAYP},
|
|
},
|
|
{
|
|
WM_NEXT,
|
|
0, {1,51},
|
|
558-42*0, 433,
|
|
{1,TX_BUTTON_NEXTP},
|
|
},
|
|
{
|
|
WM_PHASE_READ,
|
|
0, {1,52},
|
|
42+42*4, 433,
|
|
{1,TX_BUTTON_READP},
|
|
},
|
|
{
|
|
WM_PHASE_SETUP,
|
|
0, {1,47},
|
|
42+42*7, 433,
|
|
{1,TX_BUTTON_SETUP},
|
|
},
|
|
#if !_DEMO
|
|
{
|
|
WM_PHASE_BUILD,
|
|
0, {1,49},
|
|
42+42*8, 433,
|
|
{1,TX_BUTTON_BUILDP},
|
|
},
|
|
{
|
|
WM_PHASE_SKILL1,
|
|
0, {1,94},
|
|
150, 230,
|
|
{1,TX_BUTTON_SKILL},
|
|
},
|
|
{
|
|
WM_PHASE_SKILL2,
|
|
0, {1,95},
|
|
150, 230+42,
|
|
{1,TX_BUTTON_SKILL},
|
|
},
|
|
#endif
|
|
{
|
|
WM_PHASE_INIT,
|
|
0, {1,40},
|
|
42+42*0, 433,
|
|
{1,TX_BUTTON_TERM},
|
|
},
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_PLAY,
|
|
"image\\play.blp",
|
|
FALSE,
|
|
{
|
|
{
|
|
WM_PHASE_STOP,
|
|
0, {1,40},
|
|
10+42*0, 422,
|
|
0,
|
|
},
|
|
{
|
|
WM_PHASE_SETUPp,
|
|
0, {1,47},
|
|
10+42*1, 422,
|
|
0,
|
|
},
|
|
{
|
|
WM_PHASE_WRITEp,
|
|
0, {1,53},
|
|
10+42*2, 422,
|
|
0,
|
|
},
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_STOP,
|
|
"image\\stop%.3d.blp",
|
|
FALSE,
|
|
{
|
|
{
|
|
WM_PHASE_PLAY,
|
|
0, {1,77},
|
|
558-42*1, 433,
|
|
{1,TX_BUTTON_CONTP},
|
|
},
|
|
{
|
|
WM_PHASE_READ,
|
|
0, {1,52},
|
|
42+42*4, 433,
|
|
{1,TX_BUTTON_READP},
|
|
},
|
|
{
|
|
WM_PHASE_WRITE,
|
|
0, {1,53},
|
|
42+42*5, 433,
|
|
{1,TX_BUTTON_WRITEP},
|
|
},
|
|
{
|
|
WM_PHASE_SETUP,
|
|
0, {1,47},
|
|
42+42*7, 433,
|
|
{1,TX_BUTTON_SETUP},
|
|
},
|
|
{
|
|
WM_PHASE_INFO,
|
|
0, {1,78},
|
|
42+42*0, 433,
|
|
{1,TX_BUTTON_CANCELP},
|
|
},
|
|
#if !_DEMO
|
|
{
|
|
WM_PHASE_HELP,
|
|
0, {1,86},
|
|
42+42*9, 433,
|
|
{1,TX_BUTTON_HELP},
|
|
},
|
|
#endif
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_HELP,
|
|
"image\\help.blp",
|
|
TRUE,
|
|
{
|
|
{
|
|
WM_PHASE_PLAY,
|
|
0, {1,77},
|
|
558-42*1, 433,
|
|
{1,TX_BUTTON_CONTP},
|
|
},
|
|
{
|
|
WM_PHASE_READ,
|
|
0, {1,52},
|
|
42+42*4, 433,
|
|
{1,TX_BUTTON_READP},
|
|
},
|
|
{
|
|
WM_PHASE_WRITE,
|
|
0, {1,53},
|
|
42+42*5, 433,
|
|
{1,TX_BUTTON_WRITEP},
|
|
},
|
|
{
|
|
WM_PHASE_SETUP,
|
|
0, {1,47},
|
|
42+42*7, 433,
|
|
{1,TX_BUTTON_SETUP},
|
|
},
|
|
{
|
|
WM_PHASE_STOP,
|
|
0, {1,50},
|
|
42+42*0, 433,
|
|
{1,TX_BUTTON_PREVH},
|
|
},
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_SETUP,
|
|
"image\\setup.blp",
|
|
FALSE,
|
|
{
|
|
{
|
|
WM_BUTTON1,
|
|
0, {1,50},
|
|
54, 330,
|
|
{1,TX_BUTTON_SETUP1},
|
|
},
|
|
{
|
|
WM_BUTTON2,
|
|
0, {1,51},
|
|
54+40, 330,
|
|
{1,TX_BUTTON_SETUP2},
|
|
},
|
|
{
|
|
WM_BUTTON3,
|
|
0, {1,50},
|
|
284, 330,
|
|
{1,TX_BUTTON_SETUP3},
|
|
},
|
|
{
|
|
WM_BUTTON4,
|
|
0, {1,51},
|
|
284+40, 330,
|
|
{1,TX_BUTTON_SETUP4},
|
|
},
|
|
{
|
|
WM_BUTTON5,
|
|
0, {1,50},
|
|
399, 330,
|
|
{1,TX_BUTTON_SETUP5},
|
|
},
|
|
{
|
|
WM_BUTTON6,
|
|
0, {1,51},
|
|
399+40, 330,
|
|
{1,TX_BUTTON_SETUP6},
|
|
},
|
|
#if !_EGAMES
|
|
{
|
|
WM_BUTTON7,
|
|
0, {1,50},
|
|
514, 330,
|
|
{1,TX_BUTTON_SETUP7},
|
|
},
|
|
{
|
|
WM_BUTTON8,
|
|
0, {1,51},
|
|
514+40, 330,
|
|
{1,TX_BUTTON_SETUP8},
|
|
},
|
|
#endif
|
|
{
|
|
WM_BUTTON9,
|
|
0, {1,50},
|
|
169, 330,
|
|
{1,TX_BUTTON_SETUP9},
|
|
},
|
|
{
|
|
WM_BUTTON10,
|
|
0, {1,51},
|
|
169+40, 330,
|
|
{1,TX_BUTTON_SETUP10},
|
|
},
|
|
{
|
|
WM_PHASE_STOP,
|
|
0, {1,40},
|
|
11, 424,
|
|
{1,TX_BUTTON_TERM},
|
|
},
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_SETUPp,
|
|
"image\\setup.blp",
|
|
FALSE,
|
|
{
|
|
{
|
|
WM_BUTTON1,
|
|
0, {1,50},
|
|
54, 330,
|
|
{1,TX_BUTTON_SETUP1},
|
|
},
|
|
{
|
|
WM_BUTTON2,
|
|
0, {1,51},
|
|
54+40, 330,
|
|
{1,TX_BUTTON_SETUP2},
|
|
},
|
|
{
|
|
WM_BUTTON3,
|
|
0, {1,50},
|
|
284, 330,
|
|
{1,TX_BUTTON_SETUP3},
|
|
},
|
|
{
|
|
WM_BUTTON4,
|
|
0, {1,51},
|
|
284+40, 330,
|
|
{1,TX_BUTTON_SETUP4},
|
|
},
|
|
{
|
|
WM_BUTTON5,
|
|
0, {1,50},
|
|
399, 330,
|
|
{1,TX_BUTTON_SETUP5},
|
|
},
|
|
{
|
|
WM_BUTTON6,
|
|
0, {1,51},
|
|
399+40, 330,
|
|
{1,TX_BUTTON_SETUP6},
|
|
},
|
|
#if !_EGAMES
|
|
{
|
|
WM_BUTTON7,
|
|
0, {1,50},
|
|
514, 330,
|
|
{1,TX_BUTTON_SETUP7},
|
|
},
|
|
{
|
|
WM_BUTTON8,
|
|
0, {1,51},
|
|
514+40, 330,
|
|
{1,TX_BUTTON_SETUP8},
|
|
},
|
|
#endif
|
|
{
|
|
WM_BUTTON9,
|
|
0, {1,50},
|
|
169, 330,
|
|
{1,TX_BUTTON_SETUP9},
|
|
},
|
|
{
|
|
WM_BUTTON10,
|
|
0, {1,51},
|
|
169+40, 330,
|
|
{1,TX_BUTTON_SETUP10},
|
|
},
|
|
{
|
|
WM_PHASE_PLAY,
|
|
0, {1,77},
|
|
11, 424,
|
|
{1,TX_BUTTON_CONTP},
|
|
},
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_READ,
|
|
"image\\read.blp",
|
|
FALSE,
|
|
{
|
|
{
|
|
WM_READ0,
|
|
0, {0},
|
|
420, 30+42*0,
|
|
0,
|
|
},
|
|
{
|
|
WM_READ1,
|
|
0, {0},
|
|
420, 30+42*1,
|
|
0,
|
|
},
|
|
{
|
|
WM_READ2,
|
|
0, {0},
|
|
420, 30+42*2,
|
|
0,
|
|
},
|
|
{
|
|
WM_READ3,
|
|
0, {0},
|
|
420, 30+42*3,
|
|
0,
|
|
},
|
|
{
|
|
WM_READ4,
|
|
0, {0},
|
|
420, 30+42*4,
|
|
0,
|
|
},
|
|
{
|
|
WM_READ5,
|
|
0, {0},
|
|
420, 30+42*5,
|
|
0,
|
|
},
|
|
{
|
|
WM_READ6,
|
|
0, {0},
|
|
420, 30+42*6,
|
|
0,
|
|
},
|
|
{
|
|
WM_READ7,
|
|
0, {0},
|
|
420, 30+42*7,
|
|
0,
|
|
},
|
|
{
|
|
WM_READ8,
|
|
0, {0},
|
|
420, 30+42*8,
|
|
0,
|
|
},
|
|
{
|
|
WM_READ9,
|
|
0, {0},
|
|
420, 30+42*9,
|
|
0,
|
|
},
|
|
{
|
|
WM_PHASE_STOP,
|
|
0, {1,40},
|
|
16, 424,
|
|
{1,TX_BUTTON_TERM},
|
|
},
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_WRITE,
|
|
"image\\write.blp",
|
|
FALSE,
|
|
{
|
|
{
|
|
WM_WRITE0,
|
|
0, {0},
|
|
420, 30+42*0,
|
|
0,
|
|
},
|
|
{
|
|
WM_WRITE1,
|
|
0, {0},
|
|
420, 30+42*1,
|
|
0,
|
|
},
|
|
{
|
|
WM_WRITE2,
|
|
0, {0},
|
|
420, 30+42*2,
|
|
0,
|
|
},
|
|
{
|
|
WM_WRITE3,
|
|
0, {0},
|
|
420, 30+42*3,
|
|
0,
|
|
},
|
|
{
|
|
WM_WRITE4,
|
|
0, {0},
|
|
420, 30+42*4,
|
|
0,
|
|
},
|
|
{
|
|
WM_WRITE5,
|
|
0, {0},
|
|
420, 30+42*5,
|
|
0,
|
|
},
|
|
{
|
|
WM_WRITE6,
|
|
0, {0},
|
|
420, 30+42*6,
|
|
0,
|
|
},
|
|
{
|
|
WM_WRITE7,
|
|
0, {0},
|
|
420, 30+42*7,
|
|
0,
|
|
},
|
|
{
|
|
WM_WRITE8,
|
|
0, {0},
|
|
420, 30+42*8,
|
|
0,
|
|
},
|
|
{
|
|
WM_WRITE9,
|
|
0, {0},
|
|
420, 30+42*9,
|
|
0,
|
|
},
|
|
{
|
|
WM_PHASE_STOP,
|
|
0, {1,40},
|
|
16, 424,
|
|
{1,TX_BUTTON_TERM},
|
|
},
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_WRITEp,
|
|
"image\\write.blp",
|
|
FALSE,
|
|
{
|
|
{
|
|
WM_WRITE0,
|
|
0, {0},
|
|
420, 30+42*0,
|
|
0,
|
|
},
|
|
{
|
|
WM_WRITE1,
|
|
0, {0},
|
|
420, 30+42*1,
|
|
0,
|
|
},
|
|
{
|
|
WM_WRITE2,
|
|
0, {0},
|
|
420, 30+42*2,
|
|
0,
|
|
},
|
|
{
|
|
WM_WRITE3,
|
|
0, {0},
|
|
420, 30+42*3,
|
|
0,
|
|
},
|
|
{
|
|
WM_WRITE4,
|
|
0, {0},
|
|
420, 30+42*4,
|
|
0,
|
|
},
|
|
{
|
|
WM_WRITE5,
|
|
0, {0},
|
|
420, 30+42*5,
|
|
0,
|
|
},
|
|
{
|
|
WM_WRITE6,
|
|
0, {0},
|
|
420, 30+42*6,
|
|
0,
|
|
},
|
|
{
|
|
WM_WRITE7,
|
|
0, {0},
|
|
420, 30+42*7,
|
|
0,
|
|
},
|
|
{
|
|
WM_WRITE8,
|
|
0, {0},
|
|
420, 30+42*8,
|
|
0,
|
|
},
|
|
{
|
|
WM_WRITE9,
|
|
0, {0},
|
|
420, 30+42*9,
|
|
0,
|
|
},
|
|
{
|
|
WM_PHASE_PLAY,
|
|
0, {1,77},
|
|
16, 424,
|
|
{1,TX_BUTTON_CONTP},
|
|
},
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_LOST,
|
|
"image\\lost.blp",
|
|
TRUE,
|
|
{
|
|
{
|
|
WM_PHASE_INFO,
|
|
0, {1,50},
|
|
9, 431,
|
|
{1,TX_BUTTON_REPEAT},
|
|
},
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_WIN,
|
|
"image\\win.blp",
|
|
TRUE,
|
|
{
|
|
{
|
|
WM_NEXT,
|
|
0, {1,51},
|
|
9, 431,
|
|
{1,TX_BUTTON_NEXTP},
|
|
},
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_LASTWIN,
|
|
"image\\last%.3d.blp",
|
|
TRUE,
|
|
{
|
|
{
|
|
WM_PHASE_INIT,
|
|
0, {1,51},
|
|
9, 431,
|
|
{1,TX_BUTTON_NEXTP},
|
|
},
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_BUILD,
|
|
"image\\build.blp",
|
|
TRUE,
|
|
{
|
|
{
|
|
WM_DECOR1, // pose des sols
|
|
0, {6, 0,1,2,3,4,25},
|
|
11+42*2, 190+42*0,
|
|
{6,TX_OBJ_HERBE,TX_OBJ_MOUSSE,TX_OBJ_TERRE,
|
|
TX_OBJ_EAU,TX_OBJ_DALLESPEC,TX_OBJ_COUVTELE},
|
|
},
|
|
{
|
|
WM_DECOR2, // pose des plantes
|
|
0, {4, 6,7,8,11},
|
|
11+42*2, 190+42*1,
|
|
{4,TX_OBJ_DELOBJ,TX_OBJ_PLANTE,
|
|
TX_OBJ_ARBRE,TX_OBJ_FLEUR1},
|
|
},
|
|
{
|
|
WM_DECOR3, // pose des batiments
|
|
0, {11, 18,81,33,61,82,93,20,21,22,57,58},
|
|
11+42*2, 190+42*2,
|
|
{11,TX_OBJ_DELOBJ,TX_OBJ_BATIMENT,TX_OBJ_TOUR,
|
|
TX_OBJ_MINEFER,TX_OBJ_BATENNEMIS,TX_OBJ_BARENNEMIS,
|
|
TX_OBJ_MURPAL,TX_OBJ_ROC,TX_OBJ_OBJET,
|
|
TX_OBJ_ARME,TX_OBJ_VEHICULE},
|
|
},
|
|
{
|
|
WM_DECOR4, // pose des blupi
|
|
0, {10, 12,13,14,85,15,16,17,38,75,56},
|
|
11+42*2, 190+42*3,
|
|
{10,TX_OBJ_DELPERSO,TX_OBJ_BLUPIf,TX_OBJ_BLUPI,
|
|
TX_OBJ_DISCIPLE,TX_OBJ_ARAIGNEE,TX_OBJ_VIRUS,
|
|
TX_OBJ_TRACKS,TX_OBJ_BOMBE,TX_OBJ_ELECTRO,
|
|
TX_OBJ_ROBOT},
|
|
},
|
|
{
|
|
WM_DECOR5, // pose les catastrophes
|
|
0, {2, 36,37},
|
|
11+42*2, 190+42*4,
|
|
{2,TX_OBJ_DELFEU,TX_OBJ_STARTFEU},
|
|
},
|
|
{
|
|
WM_PHASE_REGION,
|
|
0, {1,5},
|
|
11+42*0, 190+42*1,
|
|
{1,TX_BUTTON_REGION},
|
|
},
|
|
{
|
|
WM_PHASE_MUSIC,
|
|
0, {1,44},
|
|
11+42*0, 190+42*2,
|
|
{1,TX_BUTTON_MUSIC},
|
|
},
|
|
{
|
|
WM_PHASE_BUTTON,
|
|
0, {1,46},
|
|
11+42*0, 190+42*3,
|
|
{1,TX_BUTTON_BUTTON},
|
|
},
|
|
{
|
|
WM_PHASE_TERM,
|
|
0, {1,45},
|
|
11+42*0, 190+42*4,
|
|
{1,TX_BUTTON_CTERM},
|
|
},
|
|
{
|
|
WM_PHASE_INFO,
|
|
0, {1,40},
|
|
11+42*0, 424,
|
|
{1,TX_BUTTON_TERMC},
|
|
},
|
|
{
|
|
WM_PHASE_UNDO,
|
|
0, {1,87},
|
|
11+42*2, 424,
|
|
{1,TX_BUTTON_UNDO},
|
|
},
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_BUTTON,
|
|
"image\\button.blp",
|
|
TRUE,
|
|
{
|
|
{
|
|
WM_BUTTON1, // stop
|
|
0, {1,40},
|
|
170+42*0, 30+52*0,
|
|
{1,TX_ACTION_STOP},
|
|
},
|
|
{
|
|
WM_BUTTON0, // go
|
|
0, {1,24},
|
|
170+42*1, 30+52*0,
|
|
{1,TX_ACTION_GO},
|
|
},
|
|
{
|
|
WM_BUTTON3, // carry
|
|
0, {1,30},
|
|
170+42*3, 30+52*0,
|
|
{1,TX_ACTION_CARRY},
|
|
},
|
|
{
|
|
WM_BUTTON4, // depose
|
|
0, {1,31},
|
|
170+42*4, 30+52*0,
|
|
{1,TX_ACTION_DEPOSE},
|
|
},
|
|
{
|
|
WM_BUTTON32, // répète
|
|
0, {1,100},
|
|
170+42*6, 30+52*0,
|
|
{1,TX_ACTION_REPEAT},
|
|
},
|
|
|
|
{
|
|
WM_BUTTON5, // abat
|
|
0, {1,22},
|
|
170+42*0, 30+52*1,
|
|
{1,TX_ACTION_ABAT},
|
|
},
|
|
{
|
|
WM_BUTTON16, // abat n
|
|
0, {1,42},
|
|
170+42*1, 30+52*1,
|
|
{1,TX_ACTION_ABATn},
|
|
},
|
|
{
|
|
WM_BUTTON6, // roc
|
|
0, {1,27},
|
|
170+42*3, 30+52*1,
|
|
{1,TX_ACTION_ROC},
|
|
},
|
|
{
|
|
WM_BUTTON17, // roc n
|
|
0, {1,43},
|
|
170+42*4, 30+52*1,
|
|
{1,TX_ACTION_ROCn},
|
|
},
|
|
{
|
|
WM_BUTTON22, // fleurs
|
|
0, {1,54},
|
|
170+42*6, 30+52*1,
|
|
{1,TX_ACTION_FLEUR},
|
|
},
|
|
{
|
|
WM_BUTTON23, // fleurs n
|
|
0, {1,55},
|
|
170+42*7, 30+52*1,
|
|
{1,TX_ACTION_FLEURn},
|
|
},
|
|
|
|
{
|
|
WM_BUTTON9, // build2 (couveuse)
|
|
0, {1,25},
|
|
170+42*0, 30+52*2,
|
|
{1,TX_ACTION_BUILD2},
|
|
},
|
|
{
|
|
WM_BUTTON15, // palis
|
|
0, {1,26},
|
|
170+42*1, 30+52*2,
|
|
{1,TX_ACTION_PALIS},
|
|
},
|
|
{
|
|
WM_BUTTON18, // pont
|
|
0, {1,23},
|
|
170+42*2, 30+52*2,
|
|
{1,TX_ACTION_PONT},
|
|
},
|
|
{
|
|
WM_BUTTON25, // bateau
|
|
0, {1,58},
|
|
170+42*3, 30+52*2,
|
|
{1,TX_ACTION_BATEAU},
|
|
},
|
|
{
|
|
WM_BUTTON13, // build6 (téléporteur)
|
|
0, {1,101},
|
|
170+42*4, 30+52*2,
|
|
{1,TX_ACTION_BUILD6},
|
|
},
|
|
{
|
|
WM_BUTTON14, // mur
|
|
0, {1,20},
|
|
170+42*6, 30+52*2,
|
|
{1,TX_ACTION_MUR},
|
|
},
|
|
{
|
|
WM_BUTTON19, // tour
|
|
0, {1,33},
|
|
170+42*7, 30+52*2,
|
|
{1,TX_ACTION_TOUR},
|
|
},
|
|
|
|
{
|
|
WM_BUTTON8, // build1 (cabane)
|
|
0, {1,19},
|
|
170+42*0, 30+52*3,
|
|
{1,TX_ACTION_BUILD1},
|
|
},
|
|
{
|
|
WM_BUTTON7, // cultive
|
|
0, {1,28},
|
|
170+42*1, 30+52*3,
|
|
{1,TX_ACTION_CULTIVE},
|
|
},
|
|
{
|
|
WM_BUTTON2, // mange
|
|
0, {1,32},
|
|
170+42*2, 30+52*3,
|
|
{1,TX_ACTION_MANGE},
|
|
},
|
|
|
|
{
|
|
WM_BUTTON10, // build3 (laboratoire)
|
|
0, {1,35},
|
|
170+42*0, 30+52*4,
|
|
{1,TX_ACTION_BUILD3},
|
|
},
|
|
{
|
|
WM_BUTTON21, // laboratoire
|
|
0, {1,39},
|
|
170+42*1, 30+52*4,
|
|
{1,TX_ACTION_LABO},
|
|
},
|
|
{
|
|
WM_BUTTON20, // boit
|
|
0, {1,34},
|
|
170+42*2, 30+52*4,
|
|
{1,TX_ACTION_BOIT},
|
|
},
|
|
{
|
|
WM_BUTTON24, // dynamite
|
|
0, {1,41},
|
|
170+42*3, 30+52*4,
|
|
{1,TX_ACTION_DYNAMITE},
|
|
},
|
|
|
|
{
|
|
WM_BUTTON27, // drapeau
|
|
0, {1,64},
|
|
170+42*0, 30+52*5,
|
|
{1,TX_ACTION_DRAPEAU},
|
|
},
|
|
{
|
|
WM_BUTTON11, // build4 (mine)
|
|
0, {1,61},
|
|
170+42*1, 30+52*5,
|
|
{1,TX_ACTION_BUILD4},
|
|
},
|
|
{
|
|
WM_BUTTON28, // extrait
|
|
0, {1,62},
|
|
170+42*2, 30+52*5,
|
|
{1,TX_ACTION_EXTRAIT},
|
|
},
|
|
{
|
|
WM_BUTTON12, // build5 (usine)
|
|
0, {1,59},
|
|
170+42*4, 30+52*5,
|
|
{1,TX_ACTION_BUILD5},
|
|
},
|
|
{
|
|
WM_BUTTON29, // fabrique jeep
|
|
0, {1,65},
|
|
170+42*5, 30+52*5,
|
|
{1,TX_ACTION_FABJEEP},
|
|
},
|
|
{
|
|
WM_BUTTON30, // fabrique mine
|
|
0, {1,63},
|
|
170+42*6, 30+52*5,
|
|
{1,TX_ACTION_FABMINE},
|
|
},
|
|
{
|
|
WM_BUTTON34, // fabrique armure
|
|
0, {1,106},
|
|
170+42*7, 30+52*5,
|
|
{1,TX_ACTION_FABARMURE},
|
|
},
|
|
{
|
|
WM_BUTTON31, // fabrique disciple
|
|
0, {1,83},
|
|
170+42*8, 30+52*5,
|
|
{1,TX_ACTION_FABDISC},
|
|
},
|
|
|
|
// {
|
|
// WM_BUTTON13, // build6
|
|
// 0, {0},
|
|
// 170+42*2, 30+52*5,
|
|
// {1,TX_ACTION_BUILD6},
|
|
// },
|
|
{
|
|
WM_PHASE_BUILD,
|
|
0, {1,50},
|
|
11, 424,
|
|
{1,TX_BUTTON_TERM},
|
|
},
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_TERM,
|
|
"image\\term.blp",
|
|
TRUE,
|
|
{
|
|
{
|
|
WM_BUTTON8, // home blupi
|
|
0, {1,81},
|
|
170+42*0, 30+42*0,
|
|
{1,TX_BUTTON_TERMMBLUPI},
|
|
},
|
|
{
|
|
WM_BUTTON9, // kill robots
|
|
0, {1,57},
|
|
170+42*1, 30+42*0,
|
|
{1,TX_BUTTON_TERMKILL},
|
|
},
|
|
{
|
|
WM_BUTTON3, // stop fire
|
|
0, {1,37},
|
|
170+42*2, 30+42*0,
|
|
{1,TX_BUTTON_TERMFIRE},
|
|
},
|
|
{
|
|
WM_BUTTON1, // hach blupi
|
|
0, {1,14},
|
|
170+42*0, 30+42*2,
|
|
{1,TX_BUTTON_TERMHBLUPI},
|
|
},
|
|
{
|
|
WM_BUTTON2, // hach planche
|
|
0, {1,22},
|
|
170+42*1, 30+42*2,
|
|
{1,TX_BUTTON_TERMHPLANCHE},
|
|
},
|
|
{
|
|
WM_BUTTON10, // hach tomate
|
|
0, {1,28},
|
|
170+42*2, 30+42*2,
|
|
{1,TX_BUTTON_TERMHTOMATE},
|
|
},
|
|
{
|
|
WM_BUTTON11, // hach métal
|
|
0, {1,84},
|
|
170+42*3, 30+42*2,
|
|
{1,TX_BUTTON_TERMHMETAL},
|
|
},
|
|
{
|
|
WM_BUTTON12, // hach robot
|
|
0, {1,94},
|
|
170+42*4, 30+42*2,
|
|
{1,TX_BUTTON_TERMHROBOT},
|
|
},
|
|
{
|
|
WM_BUTTON4, // - min blupi
|
|
0, {1,50},
|
|
170+42*0, 30+42*4,
|
|
{1,TX_BUTTON_TERMDEC},
|
|
},
|
|
{
|
|
WM_BUTTON5, // + min blupi
|
|
0, {1,51},
|
|
170+42*1, 30+42*4,
|
|
{1,TX_BUTTON_TERMINC},
|
|
},
|
|
{
|
|
WM_BUTTON6, // - max blupi
|
|
0, {1,50},
|
|
170+42*0, 30+42*5,
|
|
{1,TX_BUTTON_TERMDEC},
|
|
},
|
|
{
|
|
WM_BUTTON7, // + max blupi
|
|
0, {1,51},
|
|
170+42*1, 30+42*5,
|
|
{1,TX_BUTTON_TERMINC},
|
|
},
|
|
{
|
|
WM_PHASE_BUILD,
|
|
0, {1,50},
|
|
11, 424,
|
|
{1,TX_BUTTON_TERM},
|
|
},
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_MUSIC,
|
|
"image\\music.blp",
|
|
TRUE,
|
|
{
|
|
{
|
|
WM_BUTTON1,
|
|
0, {1,40},
|
|
170+42*0, 30+42*0,
|
|
{1,TX_BUTTON_MUSIC1},
|
|
},
|
|
{
|
|
WM_BUTTON2,
|
|
0, {1,44},
|
|
170+42*0, 30+42*1,
|
|
{1,TX_BUTTON_MUSIC2},
|
|
},
|
|
{
|
|
WM_BUTTON3,
|
|
0, {1,44},
|
|
170+42*0, 30+42*2,
|
|
{1,TX_BUTTON_MUSIC3},
|
|
},
|
|
{
|
|
WM_BUTTON4,
|
|
0, {1,44},
|
|
170+42*0, 30+42*3,
|
|
{1,TX_BUTTON_MUSIC4},
|
|
},
|
|
{
|
|
WM_BUTTON5,
|
|
0, {1,44},
|
|
170+42*0, 30+42*4,
|
|
{1,TX_BUTTON_MUSIC5},
|
|
},
|
|
{
|
|
WM_BUTTON6,
|
|
0, {1,44},
|
|
170+42*0, 30+42*5,
|
|
{1,TX_BUTTON_MUSIC6},
|
|
},
|
|
{
|
|
WM_BUTTON7,
|
|
0, {1,44},
|
|
170+42*0, 30+42*6,
|
|
{1,TX_BUTTON_MUSIC7},
|
|
},
|
|
{
|
|
WM_BUTTON8,
|
|
0, {1,44},
|
|
170+42*0, 30+42*7,
|
|
{1,TX_BUTTON_MUSIC8},
|
|
},
|
|
{
|
|
WM_BUTTON9,
|
|
0, {1,44},
|
|
170+42*0, 30+42*8,
|
|
{1,TX_BUTTON_MUSIC9},
|
|
},
|
|
{
|
|
WM_BUTTON10,
|
|
0, {1,44},
|
|
170+42*0, 30+42*9,
|
|
{1,TX_BUTTON_MUSIC10},
|
|
},
|
|
{
|
|
WM_PHASE_BUILD,
|
|
0, {1,50},
|
|
11, 424,
|
|
{1,TX_BUTTON_TERM},
|
|
},
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_REGION,
|
|
"image\\region.blp",
|
|
TRUE,
|
|
{
|
|
{
|
|
WM_BUTTON1, // normal
|
|
0, {0},
|
|
220, 60,
|
|
{1,TX_BUTTON_REGION1},
|
|
},
|
|
{
|
|
WM_BUTTON4, // sapins
|
|
0, {0},
|
|
220, 170,
|
|
{1,TX_BUTTON_REGION4},
|
|
},
|
|
{
|
|
WM_BUTTON2, // palmiers
|
|
0, {0},
|
|
220, 280,
|
|
{1,TX_BUTTON_REGION2},
|
|
},
|
|
{
|
|
WM_BUTTON3, // hivers
|
|
0, {0},
|
|
220, 390,
|
|
{1,TX_BUTTON_REGION3},
|
|
},
|
|
{
|
|
WM_PHASE_BUILD,
|
|
0, {1,50},
|
|
11, 424,
|
|
{1,TX_BUTTON_TERM},
|
|
},
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_PLAYMOVIE,
|
|
"image\\movie.blp",
|
|
FALSE,
|
|
{
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_WINMOVIE,
|
|
"image\\movie.blp",
|
|
FALSE,
|
|
{
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_H0MOVIE,
|
|
"image\\movie.blp",
|
|
FALSE,
|
|
{
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_H1MOVIE,
|
|
"image\\movie.blp",
|
|
FALSE,
|
|
{
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_H2MOVIE,
|
|
"image\\movie.blp",
|
|
FALSE,
|
|
{
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_BYE,
|
|
"image\\bye.blp",
|
|
FALSE,
|
|
{
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
WM_PHASE_INSERT,
|
|
"image\\insert.blp",
|
|
FALSE,
|
|
{
|
|
//? {
|
|
//? WM_PHASE_INFO,
|
|
//? 0, {1,48},
|
|
//? 16, 424-42,
|
|
//? {1,TX_BUTTON_PLAYP},
|
|
//? },
|
|
{
|
|
WM_PHASE_INIT,
|
|
0, {1,40},
|
|
16, 424,
|
|
{1,TX_BUTTON_QUITTER},
|
|
},
|
|
{
|
|
0
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
0
|
|
}
|
|
};
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
// Constructeur.
|
|
|
|
CEvent::CEvent()
|
|
{
|
|
int i;
|
|
|
|
m_bFullScreen = TRUE;
|
|
m_mouseType = MOUSETYPEGRA;
|
|
m_exercice = 0;
|
|
m_mission = 0;
|
|
m_private = 0;
|
|
m_maxMission = 0;
|
|
m_phase = 0;
|
|
m_index = -1;
|
|
m_bSchool = FALSE;
|
|
m_bPrivate = FALSE;
|
|
m_bAccessBuild = FALSE;
|
|
m_bRunMovie = FALSE;
|
|
m_bBuildModify = FALSE;
|
|
m_bMousePress = FALSE;
|
|
m_bMouseDown = FALSE;
|
|
m_oldMousePos.x = 0;
|
|
m_oldMousePos.y = 0;
|
|
m_mouseSprite = 0;
|
|
m_bFillMouse = FALSE;
|
|
m_bWaitMouse = FALSE;
|
|
m_bHideMouse = FALSE;
|
|
m_bShowMouse = FALSE;
|
|
m_rankCheat = -1;
|
|
m_posCheat = 0;
|
|
m_speed = 1;
|
|
m_bMovie = TRUE;
|
|
m_bSpeed = FALSE;
|
|
m_bHelp = FALSE;
|
|
m_bAllMissions = FALSE;
|
|
m_bChangeCheat = FALSE;
|
|
m_scrollSpeed = 1;
|
|
m_bPause = FALSE;
|
|
m_bShift = FALSE;
|
|
m_shiftPhase = 0;
|
|
m_movieToStart[0] = 0;
|
|
m_bInfoHelp = FALSE;
|
|
m_bDemoRec = FALSE;
|
|
m_bDemoPlay = FALSE;
|
|
m_pDemoBuffer = NULL;
|
|
m_demoTime = 0;
|
|
m_bCtrlDown = FALSE;
|
|
|
|
for ( i=0 ; i<MAXBUTTON ; i++ )
|
|
{
|
|
m_lastFloor[i] = 0;
|
|
}
|
|
|
|
for ( i=0 ; i<MAXBUTTON ; i++ )
|
|
{
|
|
m_lastObject[i] = 0;
|
|
}
|
|
|
|
for ( i=0 ; i<MAXBUTTON ; i++ )
|
|
{
|
|
m_lastHome[i] = 0;
|
|
}
|
|
}
|
|
|
|
// Destructeur.
|
|
|
|
CEvent::~CEvent()
|
|
{
|
|
WriteInfo(); // lit le fichier "info.blp"
|
|
}
|
|
|
|
|
|
// Retourne la position de la souris.
|
|
|
|
POINT CEvent::GetMousePos()
|
|
{
|
|
POINT pos;
|
|
|
|
GetCursorPos(&pos);
|
|
ScreenToClient(m_hWnd, &pos);
|
|
|
|
return pos;
|
|
}
|
|
|
|
|
|
// Initialise le mode full screen ou non.
|
|
|
|
void CEvent::SetFullScreen(BOOL bFullScreen)
|
|
{
|
|
m_bFullScreen = bFullScreen;
|
|
}
|
|
|
|
// Initialise le type de souris.
|
|
|
|
void CEvent::SetMouseType(int mouseType)
|
|
{
|
|
m_mouseType = mouseType;
|
|
}
|
|
|
|
// Crée le gestionnaire d'événements.
|
|
|
|
void CEvent::Create(HWND hWnd, CPixmap *pPixmap, CDecor *pDecor,
|
|
CSound *pSound, CMovie *pMovie)
|
|
{
|
|
POINT pos;
|
|
|
|
m_hWnd = hWnd;
|
|
m_pPixmap = pPixmap;
|
|
m_pDecor = pDecor;
|
|
m_pSound = pSound;
|
|
m_pMovie = pMovie;
|
|
|
|
ReadInfo(); // lit le fichier "info.blp"
|
|
|
|
pos.x = 10;
|
|
pos.y = 158;
|
|
m_jauges[0].Create(m_hWnd, m_pPixmap, m_pSound, pos, 1, TRUE);
|
|
|
|
pos.y += DIMJAUGEY+2;
|
|
m_jauges[1].Create(m_hWnd, m_pPixmap, m_pSound, pos, 3, TRUE);
|
|
}
|
|
|
|
|
|
// Retourne l'index d'un bouton.
|
|
|
|
int CEvent::GetButtonIndex(int button)
|
|
{
|
|
int i=0;
|
|
|
|
while ( table[m_index].buttons[i].message != 0 )
|
|
{
|
|
if ( (UINT)button == table[m_index].buttons[i].message )
|
|
{
|
|
return i;
|
|
}
|
|
i ++;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
int CEvent::GetState(int button)
|
|
{
|
|
int index;
|
|
|
|
index = GetButtonIndex(button);
|
|
if ( index < 0 ) return 0;
|
|
|
|
return m_buttons[index].GetState();
|
|
}
|
|
|
|
void CEvent::SetState(int button, int state)
|
|
{
|
|
int index;
|
|
|
|
index = GetButtonIndex(button);
|
|
if ( index < 0 ) return;
|
|
|
|
m_buttons[index].SetState(state);
|
|
}
|
|
|
|
BOOL CEvent::GetEnable(int button)
|
|
{
|
|
int index;
|
|
|
|
index = GetButtonIndex(button);
|
|
if ( index < 0 ) return 0;
|
|
|
|
return m_buttons[index].GetEnable();
|
|
}
|
|
|
|
void CEvent::SetEnable(int button, BOOL bEnable)
|
|
{
|
|
int index;
|
|
|
|
index = GetButtonIndex(button);
|
|
if ( index < 0 ) return;
|
|
|
|
m_buttons[index].SetEnable(bEnable);
|
|
}
|
|
|
|
BOOL CEvent::GetHide(int button)
|
|
{
|
|
int index;
|
|
|
|
index = GetButtonIndex(button);
|
|
if ( index < 0 ) return 0;
|
|
|
|
return m_buttons[index].GetHide();
|
|
}
|
|
|
|
void CEvent::SetHide(int button, BOOL bHide)
|
|
{
|
|
int index;
|
|
|
|
index = GetButtonIndex(button);
|
|
if ( index < 0 ) return;
|
|
|
|
m_buttons[index].SetHide(bHide);
|
|
}
|
|
|
|
int CEvent::GetMenu(int button)
|
|
{
|
|
int index;
|
|
|
|
index = GetButtonIndex(button);
|
|
if ( index < 0 ) return 0;
|
|
|
|
return m_buttons[index].GetMenu();
|
|
}
|
|
|
|
void CEvent::SetMenu(int button, int menu)
|
|
{
|
|
int index;
|
|
|
|
index = GetButtonIndex(button);
|
|
if ( index < 0 ) return;
|
|
|
|
m_buttons[index].SetMenu(menu);
|
|
}
|
|
|
|
|
|
|
|
// Restitue le jeu après une activation en mode fullScreen.
|
|
|
|
void CEvent::RestoreGame()
|
|
{
|
|
int i;
|
|
|
|
if ( m_phase == WM_PHASE_PLAY )
|
|
{
|
|
i = 0;
|
|
while ( table[m_index].buttons[i].message != 0 )
|
|
{
|
|
m_buttons[i].Redraw(); // faudra redessiner
|
|
i ++;
|
|
}
|
|
|
|
for ( i=0 ; i<2 ; i++ )
|
|
{
|
|
m_jauges[i].Redraw();
|
|
}
|
|
}
|
|
|
|
HideMouse(FALSE);
|
|
WaitMouse(TRUE);
|
|
WaitMouse(FALSE); // force le changement de sprite !
|
|
}
|
|
|
|
|
|
// Crée tous les boutons nécessaires à la phase en cours.
|
|
|
|
BOOL CEvent::CreateButtons()
|
|
{
|
|
int i=0, message;
|
|
POINT pos;
|
|
BOOL bMinimizeRedraw = FALSE;
|
|
|
|
if ( m_phase == WM_PHASE_PLAY )
|
|
{
|
|
bMinimizeRedraw = TRUE;
|
|
}
|
|
|
|
while ( table[m_index].buttons[i].message != 0 )
|
|
{
|
|
pos.x = table[m_index].buttons[i].x;
|
|
pos.y = table[m_index].buttons[i].y;
|
|
message = table[m_index].buttons[i].message;
|
|
|
|
if ( m_bPrivate )
|
|
{
|
|
if ( message == WM_PHASE_SKILL1 )
|
|
{
|
|
pos.x = 117;
|
|
pos.y = 115;
|
|
}
|
|
if ( message == WM_PHASE_SKILL2 )
|
|
{
|
|
pos.x = 117;
|
|
pos.y = 115+42;
|
|
}
|
|
}
|
|
|
|
m_buttons[i].Create(m_hWnd, m_pPixmap, m_pSound, pos,
|
|
table[m_index].buttons[i].type,
|
|
bMinimizeRedraw,
|
|
table[m_index].buttons[i].iconMenu+1,
|
|
table[m_index].buttons[i].iconMenu[0],
|
|
table[m_index].buttons[i].toolTips+1,
|
|
table[m_index].buttons[i].toolTips[0],
|
|
m_pDecor->GetRegion(),
|
|
message);
|
|
i ++;
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
// Ajoute un cheat-code dans un buffer.
|
|
|
|
void AddCheatCode(char *pDst, char *pSrc)
|
|
{
|
|
int i, j;
|
|
|
|
if ( pDst[0] != 0 ) strcat(pDst, " / ");
|
|
|
|
i = 0;
|
|
j = strlen(pDst);
|
|
while ( pSrc[i] != 0 )
|
|
{
|
|
pDst[j++] = tolower(pSrc[i++]);
|
|
}
|
|
pDst[j] = 0;
|
|
}
|
|
|
|
// Dessine un texte multi-lignes centré.
|
|
|
|
void CEvent::DrawTextCenter(int res, int x, int y, int font)
|
|
{
|
|
char text[100];
|
|
POINT pos;
|
|
|
|
LoadString(res, text, 100);
|
|
pos.x = x;
|
|
pos.y = y;
|
|
::DrawTextCenter(m_pPixmap, pos, text, font);
|
|
}
|
|
|
|
// Dessine tous les boutons de la phase en cours.
|
|
|
|
BOOL CEvent::DrawButtons()
|
|
{
|
|
int i;
|
|
int levels[2];
|
|
int types[2];
|
|
int world, time, lg, button, volume, pente, icon;
|
|
char res[100];
|
|
char text[100];
|
|
POINT pos;
|
|
RECT rect;
|
|
BOOL bEnable;
|
|
|
|
//?
|
|
#if 0
|
|
pos.x = 1;
|
|
pos.y = 1;
|
|
rect.left = pos.x;
|
|
rect.right = pos.x+50;
|
|
rect.top = pos.y;
|
|
rect.bottom = pos.y+DIMLITTLEY;
|
|
m_pPixmap->DrawPart(-1, CHBACK, pos, rect, 1); // dessine le fond
|
|
time = m_pDecor->GetTotalTime();
|
|
sprintf(text, "time=%d", time);
|
|
DrawText(m_pPixmap, pos, text, FONTLITTLE);
|
|
#endif
|
|
//?
|
|
|
|
if ( (m_phase == WM_PHASE_PLAY && m_bChangeCheat) ||
|
|
(m_phase != WM_PHASE_PLAY &&
|
|
m_phase != WM_PHASE_INSERT &&
|
|
m_phase != WM_PHASE_INTRO1 &&
|
|
m_phase != WM_PHASE_INTRO2 &&
|
|
m_phase != WM_PHASE_BYE ) )
|
|
{
|
|
m_bChangeCheat = FALSE;
|
|
|
|
text[0] = 0;
|
|
if ( m_bAllMissions )
|
|
{
|
|
AddCheatCode(text, cheat_code[3]);
|
|
}
|
|
if ( m_bSpeed )
|
|
{
|
|
AddCheatCode(text, cheat_code[4]);
|
|
}
|
|
if ( m_bHelp )
|
|
{
|
|
AddCheatCode(text, cheat_code[5]);
|
|
}
|
|
if ( m_pDecor->GetInvincible() )
|
|
{
|
|
AddCheatCode(text, cheat_code[6]);
|
|
}
|
|
if ( m_pDecor->GetSuper() )
|
|
{
|
|
AddCheatCode(text, cheat_code[7]);
|
|
}
|
|
pos.x = 2;
|
|
pos.y = 2;
|
|
rect.left = pos.x;
|
|
rect.right = pos.x+300;
|
|
rect.top = pos.y;
|
|
rect.bottom = pos.y+DIMLITTLEY;
|
|
m_pPixmap->DrawPart(-1, CHBACK, pos, rect, 1); // dessine le fond
|
|
DrawText(m_pPixmap, pos, text, FONTLITTLE);
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_INIT )
|
|
{
|
|
pos.x = 580;
|
|
pos.y = 465;
|
|
#if _EGAMES
|
|
DrawText(m_pPixmap, pos, "Version 1.0", FONTLITTLE);
|
|
#else
|
|
DrawText(m_pPixmap, pos, "Version 1.7", FONTLITTLE);
|
|
#endif
|
|
#if _DEMO
|
|
pos.x = 580;
|
|
pos.y = 465-20;
|
|
DrawText(m_pPixmap, pos, "D E M O", FONTRED);
|
|
#endif
|
|
#if _SE
|
|
pos.x = 580;
|
|
pos.y = 465-20;
|
|
DrawText(m_pPixmap, pos, "S E", FONTRED);
|
|
#endif
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_SETUP ||
|
|
m_phase == WM_PHASE_SETUPp )
|
|
{
|
|
bEnable = TRUE;
|
|
if ( m_speed == 1 ) bEnable = FALSE;
|
|
SetEnable(WM_BUTTON1, bEnable);
|
|
bEnable = TRUE;
|
|
if ( m_speed >= (m_bSpeed?8:2) ) bEnable = FALSE;
|
|
SetEnable(WM_BUTTON2, bEnable);
|
|
|
|
volume = m_pSound->GetAudioVolume();
|
|
bEnable = TRUE;
|
|
if ( volume == 0 ||
|
|
!m_pSound->GetEnable() ) bEnable = FALSE;
|
|
SetEnable(WM_BUTTON3, bEnable);
|
|
bEnable = TRUE;
|
|
if ( volume >= MAXVOLUME ||
|
|
!m_pSound->GetEnable() ) bEnable = FALSE;
|
|
SetEnable(WM_BUTTON4, bEnable);
|
|
|
|
volume = m_pSound->GetMidiVolume();
|
|
bEnable = TRUE;
|
|
if ( volume == 0 ||
|
|
!m_pSound->GetEnable() ) bEnable = FALSE;
|
|
SetEnable(WM_BUTTON5, bEnable);
|
|
bEnable = TRUE;
|
|
if ( volume >= MAXVOLUME ||
|
|
!m_pSound->GetEnable() ) bEnable = FALSE;
|
|
SetEnable(WM_BUTTON6, bEnable);
|
|
|
|
if ( m_pMovie->GetEnable() )
|
|
{
|
|
SetEnable(WM_BUTTON7, m_bMovie);
|
|
SetEnable(WM_BUTTON8, !m_bMovie);
|
|
}
|
|
else
|
|
{
|
|
SetEnable(WM_BUTTON7, FALSE);
|
|
SetEnable(WM_BUTTON8, FALSE);
|
|
}
|
|
|
|
bEnable = TRUE;
|
|
if ( m_scrollSpeed == 0 ) bEnable = FALSE;
|
|
SetEnable(WM_BUTTON9, bEnable);
|
|
bEnable = TRUE;
|
|
if ( m_scrollSpeed >= 3 ) bEnable = FALSE;
|
|
SetEnable(WM_BUTTON10, bEnable);
|
|
}
|
|
|
|
// Dessine les boutons.
|
|
i = 0;
|
|
while ( table[m_index].buttons[i].message != 0 )
|
|
{
|
|
m_buttons[i].Draw();
|
|
i ++;
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_PLAY )
|
|
{
|
|
// Dessine les jauges.
|
|
m_pDecor->GetLevelJauge(levels, types);
|
|
|
|
for ( i=0 ; i<2 ; i++ )
|
|
{
|
|
if ( levels[i] < 0 )
|
|
{
|
|
m_jauges[i].SetHide(TRUE);
|
|
}
|
|
else
|
|
{
|
|
m_jauges[i].SetHide(FALSE);
|
|
m_jauges[i].SetLevel(levels[i]);
|
|
m_jauges[i].SetType(types[i]);
|
|
}
|
|
m_jauges[i].Draw();
|
|
}
|
|
|
|
// Dessine le menu.
|
|
if ( m_menu.IsExist() )
|
|
{
|
|
m_pDecor->BlupiGetButtons(m_menuPos, m_menuNb,
|
|
m_menuButtons, m_menuErrors,
|
|
m_menuPerso);
|
|
m_menu.Update(m_menuNb, m_menuButtons, m_menuErrors);
|
|
|
|
button = m_menu.GetSel();
|
|
m_pDecor->CelHiliButton(m_menuCel, button);
|
|
}
|
|
m_menu.Draw();
|
|
|
|
// Dessine la pause.
|
|
if ( m_bPause )
|
|
{
|
|
DrawTextCenter(TX_PAUSE, (10+134)/2, 20);
|
|
}
|
|
else
|
|
{
|
|
if ( m_bDemoRec ) // démo en enregistrement ?
|
|
{
|
|
DrawTextCenter(TX_DEMOREC, (10+134)/2, 20, FONTRED);
|
|
}
|
|
if ( m_bDemoPlay ) // démo en restitution ?
|
|
{
|
|
DrawTextCenter(TX_DEMOPLAY, (10+134)/2, 20, FONTRED);
|
|
}
|
|
}
|
|
|
|
// Dessine la rose des vents.
|
|
if ( !m_bPause && !m_bDemoRec && !m_bDemoPlay )
|
|
{
|
|
DrawTextCenter(TX_DIRECT_N, (10+134)/2, 17);
|
|
DrawTextCenter(TX_DIRECT_S, (10+134)/2, 126);
|
|
DrawTextCenter(TX_DIRECT_O, 14, 70);
|
|
DrawTextCenter(TX_DIRECT_E, 129, 70);
|
|
}
|
|
|
|
// Dessine la vitesse.
|
|
pos.x = 64;
|
|
pos.y = LYIMAGE-15;
|
|
rect.left = pos.x;
|
|
rect.right = pos.x+20;
|
|
rect.top = pos.y;
|
|
rect.bottom = pos.y+15;
|
|
m_pPixmap->DrawPart(-1, CHBACK, pos, rect, 1); // dessine le fond
|
|
if ( m_speed > 1 )
|
|
{
|
|
sprintf(res, "x%d", m_speed);
|
|
DrawText(m_pPixmap, pos, res);
|
|
}
|
|
|
|
// Dessine le bouton pour les infos.
|
|
if ( m_pDecor->GetInfoMode() ) // infos visibles ?
|
|
{
|
|
lg = m_pDecor->GetInfoHeight();
|
|
|
|
pos.x = POSDRAWX;
|
|
pos.y = 0;
|
|
rect.left = POSDRAWX;
|
|
rect.right = POSDRAWX+DIMDRAWX;
|
|
rect.top = 0;
|
|
rect.bottom = lg;
|
|
m_pPixmap->DrawPart(-1, CHBACK, pos, rect, 1);
|
|
|
|
pos.x = POSDRAWX;
|
|
pos.y = lg;
|
|
rect.left = POSDRAWX;
|
|
rect.right = POSDRAWX+DIMDRAWX;
|
|
rect.top = 0;
|
|
rect.bottom = POSDRAWY;
|
|
m_pPixmap->DrawPart(-1, CHBACK, pos, rect, 1);
|
|
|
|
pos.x = POSDRAWX+20;
|
|
pos.y = POSDRAWY+4;
|
|
DrawTextRect(m_pPixmap, pos, m_libelle, 0, FONTLITTLE, 1);
|
|
pos.x = POSDRAWX+DIMDRAWX/2+20;
|
|
DrawTextRect(m_pPixmap, pos, m_libelle, 0, FONTLITTLE, 2);
|
|
|
|
pos.x = POSDRAWX+DIMDRAWX/2-DIMBUTTONX/2;
|
|
pos.y = lg-14;
|
|
m_pPixmap->DrawIcon(-1, CHBUTTON, m_bHiliInfoButton?73:72, pos);
|
|
|
|
if ( IsHelpHide() ) // bouton pour aide ?
|
|
{
|
|
m_posHelpButton.x = -1;
|
|
}
|
|
else
|
|
{
|
|
m_posHelpButton.x = POSDRAWX+DIMDRAWX-DIMBUTTONX-2;
|
|
m_posHelpButton.y = lg-DIMBUTTONY-2;
|
|
m_pPixmap->DrawIcon(-1, CHBUTTON, m_bHiliHelpButton?2:0, m_posHelpButton);
|
|
if ( m_bInfoHelp ) icon = 86; // livre
|
|
else icon = 92; // aide
|
|
m_pPixmap->DrawIcon(-1, CHBUTTON, icon, m_posHelpButton);
|
|
}
|
|
}
|
|
else // infos cachées ?
|
|
{
|
|
pos.x = POSDRAWX+DIMDRAWX/2-DIMBUTTONX/2;
|
|
pos.y = -12;
|
|
m_pPixmap->DrawIcon(-1, CHBUTTON, m_bHiliInfoButton?75:74, pos);
|
|
}
|
|
m_posInfoButton = pos;
|
|
}
|
|
|
|
// Dessine les noms des fichiers.
|
|
if ( m_phase == WM_PHASE_READ ||
|
|
m_phase == WM_PHASE_WRITE ||
|
|
m_phase == WM_PHASE_WRITEp )
|
|
{
|
|
if ( m_phase == WM_PHASE_READ )
|
|
{
|
|
LoadString(TX_BUTTON_READP, res, 50);
|
|
}
|
|
else
|
|
{
|
|
LoadString(TX_BUTTON_WRITEP, res, 50);
|
|
}
|
|
pos.x = 420;
|
|
pos.y = 8;
|
|
DrawText(m_pPixmap, pos, res);
|
|
|
|
for ( i=0 ; i<10 ; i++ )
|
|
{
|
|
world = m_fileWorld[i];
|
|
time = m_fileTime[i];
|
|
|
|
sprintf(text, "%d", i+1);
|
|
lg = GetTextWidth(text);
|
|
pos.x = (420+460)/2-lg/2;
|
|
pos.y = 30+12+42*i;
|
|
DrawText(m_pPixmap, pos, text, FONTSLIM);
|
|
|
|
pos.x = 420+50;
|
|
|
|
if ( world >= 0 )
|
|
{
|
|
if ( world >= 200 )
|
|
{
|
|
LoadString(TX_IONAMEPR, res, 50);
|
|
sprintf(text, res, (world-200)+1, time/100);
|
|
}
|
|
else if ( world >= 100 )
|
|
{
|
|
LoadString(TX_IONAMEMI, res, 50);
|
|
sprintf(text, res, (world-100)+1, time/100);
|
|
}
|
|
else
|
|
{
|
|
LoadString(TX_IONAMEEX, res, 50);
|
|
sprintf(text, res, world+1, time/100);
|
|
}
|
|
DrawText(m_pPixmap, pos, text); // partie x, temps t
|
|
}
|
|
else
|
|
{
|
|
LoadString(TX_IOFREE, res, 50);
|
|
DrawText(m_pPixmap, pos, res, FONTRED); // libre
|
|
}
|
|
}
|
|
}
|
|
|
|
// Dessine les réglages pour la fin de la partie.
|
|
if ( m_phase == WM_PHASE_TERM )
|
|
{
|
|
Term* pTerm = m_pDecor->GetTerminated();
|
|
|
|
DrawTextCenter(TX_TERM, (10+134)/2, 20);
|
|
|
|
pos.x = 170+42*2+4;
|
|
pos.y = 30+12+42*4;
|
|
LoadString(TX_TERMMIN, res, 50);
|
|
sprintf(text, res, pTerm->nbMinBlupi);
|
|
DrawText(m_pPixmap, pos, text);
|
|
|
|
pos.x = 170+42*2+4;
|
|
pos.y = 30+12+42*5;
|
|
LoadString(TX_TERMMAX, res, 50);
|
|
sprintf(text, res, pTerm->nbMaxBlupi);
|
|
DrawText(m_pPixmap, pos, text);
|
|
}
|
|
|
|
// Dessine les textes pour les choix des boutons.
|
|
if ( m_phase == WM_PHASE_BUTTON )
|
|
{
|
|
DrawTextCenter(TX_BUTTON, (10+134)/2, 20);
|
|
}
|
|
|
|
// Dessine les textes pour le choix des musiques.
|
|
if ( m_phase == WM_PHASE_MUSIC )
|
|
{
|
|
DrawTextCenter(TX_MUSIC, (10+134)/2, 20);
|
|
}
|
|
|
|
// Dessine les textes pour le choix de la région.
|
|
if ( m_phase == WM_PHASE_REGION )
|
|
{
|
|
DrawTextCenter(TX_REGION, (10+134)/2, 20);
|
|
}
|
|
|
|
// Ajoute "Mission numéro".
|
|
if ( m_phase == WM_PHASE_INFO )
|
|
{
|
|
if ( m_bSchool ) LoadString(TX_SCHOOL, res, 50);
|
|
else LoadString(TX_MISSION, res, 50);
|
|
if ( m_bPrivate ) LoadString(TX_PRIVATE, res, 50);
|
|
|
|
lg = GetTextWidth(res);
|
|
pos.x = (140+270)/2-lg/2;
|
|
pos.y = 70;
|
|
if ( m_bSchool ) pos.x -= 40;
|
|
if ( m_bPrivate ) pos.x -= 100;
|
|
if ( m_bPrivate ) pos.y += 14;
|
|
DrawText(m_pPixmap, pos, res, FONTSLIM);
|
|
}
|
|
|
|
// Ajoute le texte "Partie interrompue".
|
|
if ( m_phase == WM_PHASE_STOP )
|
|
{
|
|
LoadString(TX_PAUSE, res, 50);
|
|
lg = GetTextWidth(res);
|
|
pos.x = (140+270)/2-lg/2;
|
|
pos.y = 70;
|
|
if ( m_bSchool ) pos.x -= 40;
|
|
if ( m_bPrivate ) pos.x -= 100;
|
|
if ( m_bPrivate ) pos.y += 14;
|
|
DrawText(m_pPixmap, pos, res, FONTRED);
|
|
}
|
|
|
|
// Ajoute le texte "Informations complémentaires".
|
|
if ( m_phase == WM_PHASE_HELP )
|
|
{
|
|
LoadString(TX_HELP, res, 50);
|
|
lg = GetTextWidth(res);
|
|
pos.x = (140+270)/2-lg/2;
|
|
pos.y = 70;
|
|
if ( m_bSchool ) pos.x -= 40;
|
|
if ( m_bPrivate ) pos.x -= 100;
|
|
if ( m_bPrivate ) pos.y += 14;
|
|
DrawText(m_pPixmap, pos, res, FONTRED);
|
|
}
|
|
|
|
// Ajoute le numéro du monde.
|
|
if ( m_phase == WM_PHASE_INFO ||
|
|
m_phase == WM_PHASE_STOP ||
|
|
m_phase == WM_PHASE_HELP )
|
|
{
|
|
if ( m_bSchool ) world = m_exercice;
|
|
else world = m_mission;
|
|
if ( m_bPrivate ) world = m_private;
|
|
|
|
lg = GetBignumWidth(world+1);
|
|
pos.x = (140+270)/2-lg/2;
|
|
pos.y = 100;
|
|
if ( m_bSchool ) pos.x -= 40;
|
|
if ( m_bPrivate ) pos.x -= 135;
|
|
if ( m_bPrivate ) pos.y = 115;
|
|
DrawBignum(m_pPixmap, pos, world+1);
|
|
}
|
|
|
|
#if !_DEMO
|
|
// Affiche facile/difficile.
|
|
if ( m_phase == WM_PHASE_INFO )
|
|
{
|
|
if ( !m_bSchool )
|
|
{
|
|
if ( m_pDecor->GetSkill() == 0 )
|
|
{
|
|
LoadString(TX_SKILL1, res, 50);
|
|
if ( m_bPrivate )
|
|
{
|
|
pos.x = 117+50;
|
|
pos.y = 115+13;
|
|
}
|
|
else
|
|
{
|
|
pos.x = 150+50;
|
|
pos.y = 230+13;
|
|
}
|
|
DrawText(m_pPixmap, pos, res, FONTSLIM);
|
|
}
|
|
|
|
if ( m_pDecor->GetSkill() == 1 )
|
|
{
|
|
LoadString(TX_SKILL2, res, 50);
|
|
if ( m_bPrivate )
|
|
{
|
|
pos.x = 117+50;
|
|
pos.y = 115+42+13;
|
|
}
|
|
else
|
|
{
|
|
pos.x = 150+50;
|
|
pos.y = 230+42+13;
|
|
}
|
|
DrawText(m_pPixmap, pos, res, FONTSLIM);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Affiche le libellé de l'énigme.
|
|
if ( m_phase == WM_PHASE_INFO ||
|
|
m_phase == WM_PHASE_STOP ||
|
|
m_phase == WM_PHASE_HELP ||
|
|
m_phase == WM_PHASE_HISTORY0 ||
|
|
m_phase == WM_PHASE_HISTORY1 )
|
|
{
|
|
pos.x = 355;
|
|
pos.y = 70;
|
|
if ( m_bSchool ) pos.x -= 20;
|
|
if ( m_bPrivate )
|
|
{
|
|
pos.x = 460;
|
|
pos.y = 260;
|
|
}
|
|
if ( m_bSchool || m_bPrivate ) pente = 0;
|
|
else pente = 19;
|
|
DrawTextRect(m_pPixmap, pos, m_libelle, pente, FONTSLIM);
|
|
}
|
|
|
|
// Affiche le texte lorsque c'est raté.
|
|
if ( m_phase == WM_PHASE_LOST )
|
|
{
|
|
LoadString(TX_LOST1+GetWorld()%5, res, 50);
|
|
pos.x = 60;
|
|
pos.y = 443;
|
|
DrawText(m_pPixmap, pos, res);
|
|
}
|
|
|
|
// Affiche le texte lorsque c'est réussi.
|
|
if ( m_phase == WM_PHASE_WIN )
|
|
{
|
|
LoadString(TX_WIN1+GetWorld()%5, res, 50);
|
|
pos.x = 60;
|
|
pos.y = 443;
|
|
DrawText(m_pPixmap, pos, res);
|
|
}
|
|
|
|
// Affiche le texte lorsque c'est fini.
|
|
if ( m_phase == WM_PHASE_LASTWIN )
|
|
{
|
|
if ( m_bSchool ) LoadString(TX_LASTWIN1, res, 50);
|
|
else LoadString(TX_LASTWIN2, res, 50);
|
|
if ( m_bPrivate ) LoadString(TX_LASTWIN3, res, 50);
|
|
pos.x = 60;
|
|
pos.y = 443;
|
|
DrawText(m_pPixmap, pos, res);
|
|
}
|
|
|
|
// Dessine les réglages.
|
|
if ( m_phase == WM_PHASE_SETUP ||
|
|
m_phase == WM_PHASE_SETUPp )
|
|
{
|
|
DrawTextCenter(TX_INFO_SETUP1, 54+40, 80);
|
|
DrawTextCenter(TX_INFO_SETUP5, 169+40, 80);
|
|
DrawTextCenter(TX_INFO_SETUP2, 284+40, 80);
|
|
DrawTextCenter(TX_INFO_SETUP3, 399+40, 80);
|
|
#if !_EGAMES
|
|
DrawTextCenter(TX_INFO_SETUP4, 514+40, 80);
|
|
#endif
|
|
|
|
sprintf(res, "x%d", m_speed);
|
|
lg = GetTextWidth(res);
|
|
pos.x = (54+40)-lg/2;
|
|
pos.y = 330-20;
|
|
DrawText(m_pPixmap, pos, res);
|
|
|
|
sprintf(res, "%d", m_pSound->GetAudioVolume());
|
|
lg = GetTextWidth(res);
|
|
pos.x = (284+40)-lg/2;
|
|
pos.y = 330-20;
|
|
DrawText(m_pPixmap, pos, res);
|
|
|
|
sprintf(res, "%d", m_pSound->GetMidiVolume());
|
|
lg = GetTextWidth(res);
|
|
pos.x = (399+40)-lg/2;
|
|
pos.y = 330-20;
|
|
DrawText(m_pPixmap, pos, res);
|
|
|
|
#if !_EGAMES
|
|
if ( m_pMovie->GetEnable() )
|
|
{
|
|
if ( m_bMovie ) LoadString(TX_OUI, res, 50);
|
|
else LoadString(TX_NON, res, 50);
|
|
}
|
|
else
|
|
{
|
|
LoadString(TX_NON, res, 50);
|
|
}
|
|
lg = GetTextWidth(res);
|
|
pos.x = (514+40)-lg/2;
|
|
pos.y = 330-20;
|
|
DrawText(m_pPixmap, pos, res);
|
|
#endif
|
|
|
|
if ( m_scrollSpeed == 0 ) LoadString(TX_INFO_NOSCROLL, res, 50);
|
|
else sprintf(res, "%d", m_scrollSpeed);
|
|
lg = GetTextWidth(res);
|
|
pos.x = (169+40)-lg/2;
|
|
pos.y = 330-20;
|
|
DrawText(m_pPixmap, pos, res);
|
|
}
|
|
|
|
// Affiche le texte de fin de la version demo.
|
|
if ( m_phase == WM_PHASE_BYE )
|
|
{
|
|
#if _DEMO
|
|
LoadString(TX_DEMO_END1, res, 100);
|
|
#else
|
|
LoadString(TX_FULL_END1, res, 100);
|
|
#endif
|
|
lg = GetTextWidth(res);
|
|
pos.x = LXIMAGE/2-lg/2;
|
|
pos.y = 20;
|
|
DrawText(m_pPixmap, pos, res);
|
|
#if _DEMO
|
|
LoadString(TX_DEMO_END2, res, 100);
|
|
#else
|
|
LoadString(TX_FULL_END2, res, 100);
|
|
#endif
|
|
lg = GetTextWidth(res);
|
|
pos.x = LXIMAGE/2-lg/2;
|
|
pos.y = 40;
|
|
DrawText(m_pPixmap, pos, res);
|
|
|
|
#if _DEMO
|
|
LoadString(TX_DEMO_END3, res, 100);
|
|
#else
|
|
LoadString(TX_FULL_END3, res, 100);
|
|
#endif
|
|
lg = GetTextWidth(res);
|
|
pos.x = LXIMAGE/2-lg/2;
|
|
pos.y = 430;
|
|
DrawText(m_pPixmap, pos, res);
|
|
#if _DEMO
|
|
LoadString(TX_DEMO_END4, res, 100);
|
|
#else
|
|
LoadString(TX_FULL_END4, res, 100);
|
|
#endif
|
|
lg = GetTextWidth(res);
|
|
pos.x = LXIMAGE/2-lg/2;
|
|
pos.y = 450;
|
|
DrawText(m_pPixmap, pos, res);
|
|
}
|
|
|
|
// Affiche le texte lorsqu'il faut insérer le CD-Rom.
|
|
if ( m_phase == WM_PHASE_INSERT )
|
|
{
|
|
DrawTextCenter(TX_INSERT, LXIMAGE/2, 20);
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_BUILD )
|
|
{
|
|
SetEnable(WM_PHASE_UNDO, m_pDecor->IsUndo());
|
|
}
|
|
|
|
// Dessine les tool tips (info bulle).
|
|
if ( m_textToolTips[0] != 0 )
|
|
{
|
|
DrawText(m_pPixmap, m_posToolTips, m_textToolTips);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// Retourne le lutin à utiliser à une position donnée.
|
|
|
|
int CEvent::MousePosToSprite(POINT pos)
|
|
{
|
|
int sprite;
|
|
BOOL bUp=FALSE, bDown=FALSE, bLeft=FALSE, bRight=FALSE;
|
|
|
|
sprite = SPRITE_POINTER;
|
|
|
|
if ( m_phase == WM_PHASE_PLAY ||
|
|
m_phase == WM_PHASE_BUILD )
|
|
{
|
|
if ( pos.x >= POSMAPX && pos.x <= POSMAPX+DIMMAPX &&
|
|
pos.y >= POSMAPY && pos.y <= POSMAPY+DIMMAPY )
|
|
{
|
|
sprite = SPRITE_MAP;
|
|
}
|
|
|
|
if ( m_bFullScreen &&
|
|
!m_bDemoRec &&
|
|
!m_bDemoPlay &&
|
|
m_scrollSpeed != 0 )
|
|
{
|
|
if ( pos.x <= 5 && pos.x >= -2 )
|
|
{
|
|
bLeft = TRUE;
|
|
}
|
|
|
|
if ( pos.x >= LXIMAGE-5 && pos.x <= LXIMAGE+2 )
|
|
{
|
|
bRight = TRUE;
|
|
}
|
|
|
|
if ( pos.y <= 5 && pos.y >= -2 )
|
|
{
|
|
bUp = TRUE;
|
|
}
|
|
|
|
if ( pos.y >= LYIMAGE-5 && pos.y <= LYIMAGE+2 )
|
|
{
|
|
bDown = TRUE;
|
|
}
|
|
|
|
if ( bLeft ) sprite = SPRITE_ARROWL;
|
|
if ( bRight ) sprite = SPRITE_ARROWR;
|
|
if ( bUp ) sprite = SPRITE_ARROWU;
|
|
if ( bDown ) sprite = SPRITE_ARROWD;
|
|
if ( bLeft && bUp ) sprite = SPRITE_ARROWUL;
|
|
if ( bLeft && bDown ) sprite = SPRITE_ARROWDL;
|
|
if ( bRight && bUp ) sprite = SPRITE_ARROWUR;
|
|
if ( bRight && bDown ) sprite = SPRITE_ARROWDR;
|
|
}
|
|
}
|
|
else if ( m_phase == WM_PHASE_INTRO1 ||
|
|
m_phase == WM_PHASE_INTRO2 )
|
|
{
|
|
sprite = SPRITE_POINTER;
|
|
}
|
|
else if ( m_phase == WM_PHASE_BYE )
|
|
{
|
|
sprite = SPRITE_POINTER;
|
|
}
|
|
else
|
|
{
|
|
if ( !MouseOnButton(pos) )
|
|
{
|
|
sprite = SPRITE_ARROW;
|
|
}
|
|
}
|
|
|
|
if ( m_bFillMouse && // bidon présent ?
|
|
pos.x >= POSDRAWX && pos.x <= POSDRAWX+DIMDRAWX &&
|
|
pos.y >= POSDRAWY && pos.y <= POSDRAWY+DIMDRAWY )
|
|
{
|
|
sprite = SPRITE_FILL;
|
|
}
|
|
if ( m_bWaitMouse ) // sablier présent ?
|
|
{
|
|
sprite = SPRITE_WAIT;
|
|
}
|
|
if ( m_bHideMouse ) // souris cachée ?
|
|
{
|
|
sprite = SPRITE_EMPTY;
|
|
}
|
|
|
|
return sprite;
|
|
}
|
|
|
|
// Gère le lutin de la souris.
|
|
|
|
void CEvent::MouseSprite(POINT pos)
|
|
{
|
|
m_mouseSprite = MousePosToSprite(pos);
|
|
|
|
m_pPixmap->SetMousePosSprite(pos, m_mouseSprite, m_bDemoPlay);
|
|
ChangeSprite(m_mouseSprite);
|
|
}
|
|
|
|
// Met ou enlève le sablier de la souris.
|
|
|
|
void CEvent::WaitMouse(BOOL bWait)
|
|
{
|
|
m_bWaitMouse = bWait;
|
|
|
|
if ( bWait )
|
|
{
|
|
m_mouseSprite = SPRITE_WAIT;
|
|
}
|
|
else
|
|
{
|
|
m_mouseSprite = MousePosToSprite(GetMousePos());
|
|
}
|
|
m_pPixmap->SetMouseSprite(m_mouseSprite, m_bDemoPlay);
|
|
ChangeSprite(m_mouseSprite);
|
|
}
|
|
|
|
// Cache ou montre la souris.
|
|
|
|
void CEvent::HideMouse(BOOL bHide)
|
|
{
|
|
m_bHideMouse = bHide;
|
|
|
|
if ( bHide )
|
|
{
|
|
m_mouseSprite = SPRITE_EMPTY;
|
|
}
|
|
else
|
|
{
|
|
m_mouseSprite = MousePosToSprite(GetMousePos());
|
|
}
|
|
m_pPixmap->SetMouseSprite(m_mouseSprite, m_bDemoPlay);
|
|
ChangeSprite(m_mouseSprite);
|
|
}
|
|
|
|
// Traite les événements pour tous les boutons.
|
|
|
|
BOOL CEvent::EventButtons(UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
POINT pos, test;
|
|
int i, lg, oldx, sound, res;
|
|
|
|
pos = ConvLongToPos(lParam);
|
|
|
|
// Cherche le tool tips à utiliser pour la souris.
|
|
m_textToolTips[0] = 0;
|
|
oldx = m_posToolTips.x;
|
|
m_posToolTips.x = -1;
|
|
if ( m_phase == WM_PHASE_PLAY )
|
|
{
|
|
for ( i=0 ; i<2 ; i++ )
|
|
{
|
|
if ( !m_jauges[i].GetHide() )
|
|
{
|
|
test = m_jauges[i].GetPos();
|
|
if ( pos.x >= test.x &&
|
|
pos.x <= test.x+DIMJAUGEX &&
|
|
pos.y >= test.y &&
|
|
pos.y <= test.y+DIMJAUGEY )
|
|
{
|
|
LoadString(TX_JAUGE1+i, m_textToolTips, 50);
|
|
lg = GetTextWidth(m_textToolTips);
|
|
test.x += (DIMJAUGEX-lg)/2;
|
|
test.y += 4;
|
|
m_posToolTips = test;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if ( oldx != m_posToolTips.x )
|
|
{
|
|
for ( i=0 ; i<2 ; i++ )
|
|
{
|
|
m_jauges[i].SetRedraw();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
i = 0;
|
|
while ( table[m_index].buttons[i].message != 0 )
|
|
{
|
|
res = m_buttons[i].GetToolTips(pos);
|
|
if ( res != -1 )
|
|
{
|
|
LoadString(res, m_textToolTips, 50);
|
|
lg = GetTextWidth(m_textToolTips);
|
|
pos.x += 10;
|
|
pos.y += 20;
|
|
if ( pos.x > LXIMAGE-lg ) pos.x = LXIMAGE-lg;
|
|
if ( pos.y > LYIMAGE-14 ) pos.y = LYIMAGE-14;
|
|
m_posToolTips = pos;
|
|
break;
|
|
}
|
|
i ++;
|
|
}
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_PLAY )
|
|
{
|
|
m_bHiliInfoButton = FALSE;
|
|
if ( pos.x > m_posInfoButton.x+6 &&
|
|
pos.x < m_posInfoButton.x+DIMBUTTONX-6 &&
|
|
pos.y > m_posInfoButton.y+8 &&
|
|
pos.y < m_posInfoButton.y+DIMBUTTONY-8 )
|
|
{
|
|
m_bHiliInfoButton = TRUE;
|
|
|
|
if ( message == WM_LBUTTONDOWN ||
|
|
message == WM_RBUTTONDOWN )
|
|
{
|
|
if ( m_pDecor->GetInfoMode() ) sound = SOUND_CLOSE;
|
|
else sound = SOUND_OPEN;
|
|
m_pSound->PlayImage(sound, pos);
|
|
}
|
|
if ( message == WM_LBUTTONUP ||
|
|
message == WM_RBUTTONUP )
|
|
{
|
|
// Montre ou cache les infos tout en haut.
|
|
m_pDecor->SetInfoMode(!m_pDecor->GetInfoMode());
|
|
}
|
|
}
|
|
|
|
m_bHiliHelpButton = FALSE;
|
|
if ( m_posHelpButton.x != -1 &&
|
|
pos.x > m_posHelpButton.x &&
|
|
pos.x < m_posHelpButton.x+DIMBUTTONX &&
|
|
pos.y > m_posHelpButton.y &&
|
|
pos.y < m_posHelpButton.y+DIMBUTTONY )
|
|
{
|
|
m_bHiliHelpButton = TRUE;
|
|
|
|
if ( message == WM_LBUTTONDOWN ||
|
|
message == WM_RBUTTONDOWN )
|
|
{
|
|
m_pSound->PlayImage(SOUND_CLICK, pos);
|
|
}
|
|
if ( message == WM_LBUTTONUP ||
|
|
message == WM_RBUTTONUP )
|
|
{
|
|
// Inverse le mode aide dans les infos.
|
|
m_bInfoHelp = !m_bInfoHelp;
|
|
|
|
if ( m_bInfoHelp )
|
|
{
|
|
ReadLibelle(GetWorld(), FALSE, TRUE);
|
|
}
|
|
else
|
|
{
|
|
ReadLibelle(GetWorld()+2, FALSE, FALSE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_BUILD )
|
|
{
|
|
if ( message == WM_LBUTTONDOWN ||
|
|
message == WM_RBUTTONDOWN )
|
|
{
|
|
m_pDecor->HideTooltips(TRUE); // plus de tooltips pour décor
|
|
}
|
|
if ( message == WM_LBUTTONUP ||
|
|
message == WM_RBUTTONUP )
|
|
{
|
|
m_pDecor->HideTooltips(FALSE);
|
|
}
|
|
}
|
|
|
|
|
|
i = 0;
|
|
while ( table[m_index].buttons[i].message != 0 )
|
|
{
|
|
if ( m_buttons[i].TreatEvent(message, wParam, lParam) ) return TRUE;
|
|
i ++;
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_PLAY )
|
|
{
|
|
if ( m_menu.TreatEvent(message, wParam, lParam) ) return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// Indique si la souris est sur un bouton.
|
|
|
|
BOOL CEvent::MouseOnButton(POINT pos)
|
|
{
|
|
int i;
|
|
|
|
i = 0;
|
|
while ( table[m_index].buttons[i].message != 0 )
|
|
{
|
|
if ( m_buttons[i].MouseOnButton(pos) ) return TRUE;
|
|
i ++;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// Retourne l'index dans table pour une phase donnée.
|
|
|
|
int CEvent::SearchPhase(UINT phase)
|
|
{
|
|
int i=0;
|
|
|
|
while ( table[i].phase != 0 )
|
|
{
|
|
if ( table[i].phase == phase ) return i;
|
|
i ++;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
// Donne le numéro du monde.
|
|
|
|
int CEvent::GetWorld()
|
|
{
|
|
if ( m_bPrivate ) return m_private;
|
|
if ( m_bSchool ) return m_exercice;
|
|
else return m_mission;
|
|
}
|
|
|
|
// Donne le numéro physique du monde.
|
|
|
|
int CEvent::GetPhysicalWorld()
|
|
{
|
|
if ( m_bPrivate ) return m_private+200;
|
|
if ( m_bSchool ) return m_exercice;
|
|
else return m_mission+100;
|
|
}
|
|
|
|
int CEvent::GetImageWorld()
|
|
{
|
|
if ( m_bPrivate ) return 2;
|
|
if ( m_bSchool ) return 0;
|
|
else return 1;
|
|
}
|
|
|
|
// Indique si l'aide est disponible.
|
|
|
|
BOOL CEvent::IsHelpHide()
|
|
{
|
|
BOOL bHide = TRUE;
|
|
|
|
#if !_DEMO
|
|
if ( m_bHelp || m_pDecor->GetTotalTime() > DEF_TIME_HELP )
|
|
{
|
|
bHide = FALSE;
|
|
}
|
|
if ( m_bSchool || m_bPrivate )
|
|
{
|
|
bHide = TRUE; // pas d'aide pour les exercices
|
|
}
|
|
#endif
|
|
return bHide;
|
|
}
|
|
|
|
// Change de phase.
|
|
|
|
BOOL CEvent::ChangePhase(UINT phase)
|
|
{
|
|
int index, world, time, total, music, i, max;
|
|
POINT totalDim, iconDim;
|
|
char filename[MAX_PATH];
|
|
char* pButtonExist;
|
|
BOOL bEnable, bHide;
|
|
Term* pTerm;
|
|
|
|
if ( m_mouseType == MOUSETYPEGRA && m_bFullScreen )
|
|
{
|
|
ShowCursor(FALSE); // cache la vilaine souris Windows
|
|
m_bShowMouse = FALSE;
|
|
}
|
|
|
|
if ( phase != WM_PHASE_SETUPp &&
|
|
phase != WM_PHASE_WRITEp &&
|
|
phase != WM_PHASE_PLAY )
|
|
{
|
|
m_pSound->StopMusic();
|
|
}
|
|
if ( phase == WM_PHASE_SETUPp && m_bPause )
|
|
{
|
|
m_pSound->StopMusic();
|
|
}
|
|
|
|
m_textToolTips[0] = 0;
|
|
m_posToolTips.x = -1;
|
|
m_bPause = FALSE;
|
|
m_bCtrlDown = FALSE;
|
|
m_bMouseDown = FALSE;
|
|
m_debugPos.x = 0;
|
|
m_debugPos.y = 0;
|
|
|
|
m_pDecor->SetInfoMode(FALSE);
|
|
m_bInfoHelp = FALSE;
|
|
m_bHiliInfoButton = FALSE;
|
|
m_bHiliHelpButton = FALSE;
|
|
|
|
if ( phase == WM_PHASE_INTRO1 ||
|
|
phase == WM_PHASE_INTRO2 )
|
|
{
|
|
m_introTime = 0;
|
|
}
|
|
|
|
if ( phase == WM_PHASE_INIT )
|
|
{
|
|
m_demoTime = 0;
|
|
}
|
|
if ( phase == WM_PHASE_PLAY &&
|
|
!m_bDemoPlay &&
|
|
GetPhysicalWorld() >= 150 && // mission spéciale démo ?
|
|
GetPhysicalWorld() < 200 )
|
|
{
|
|
DemoRecStart(); // début enregistrement
|
|
}
|
|
if ( phase != WM_PHASE_PLAY )
|
|
{
|
|
DemoRecStop(); // stoppe l'enregistrement d'une démo
|
|
}
|
|
|
|
m_pDecor->UndoClose(); // libère le buffer undo
|
|
|
|
index = SearchPhase(phase);
|
|
if ( index < 0 ) return FALSE;
|
|
|
|
HideMouse(FALSE); // montre la souris
|
|
WaitMouse(TRUE); // met le sablier
|
|
|
|
if ( m_bBuildModify )
|
|
{
|
|
m_pDecor->InitAfterBuild();
|
|
m_bBuildModify = FALSE;
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_BUILD &&
|
|
phase == WM_PHASE_INFO ) // quitte construction ?
|
|
{
|
|
m_pDecor->Write(GetPhysicalWorld(), FALSE,
|
|
GetPhysicalWorld(), 0, 0); // écrit le monde
|
|
}
|
|
|
|
m_phase = phase; // change de phase
|
|
m_index = index;
|
|
|
|
strcpy(filename, table[m_index].backName);
|
|
if ( strstr(filename, "%.3d") != NULL ) // "%.3d" dans le nom ?
|
|
{
|
|
sprintf(filename, table[m_index].backName, GetImageWorld());
|
|
}
|
|
if ( table[m_index].bCDrom ) // sur le CD-rom ?
|
|
{
|
|
AddCDPath(filename);
|
|
}
|
|
totalDim.x = LXIMAGE;
|
|
totalDim.y = LYIMAGE;
|
|
iconDim.x = 0;
|
|
iconDim.y = 0;
|
|
if ( !m_pPixmap->Cache(CHBACK, filename, totalDim, iconDim, FALSE) )
|
|
{
|
|
WaitMouse(FALSE); // enlève le sablier
|
|
m_tryInsertCount = 40;
|
|
m_tryPhase = m_phase;
|
|
return ChangePhase(WM_PHASE_INSERT); // insérez le CD-Rom ...
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_READ ||
|
|
m_phase == WM_PHASE_WRITE ||
|
|
m_phase == WM_PHASE_WRITEp )
|
|
{
|
|
for ( i=0 ; i<10 ; i++ )
|
|
{
|
|
if ( m_pDecor->FileExist(i, TRUE, world, time, total) )
|
|
{
|
|
m_fileWorld[i] = world;
|
|
m_fileTime[i] = time;
|
|
}
|
|
else
|
|
{
|
|
m_fileWorld[i] = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_INFO ||
|
|
m_phase == WM_PHASE_HISTORY0 ||
|
|
m_phase == WM_PHASE_HISTORY1 )
|
|
{
|
|
if ( !m_pDecor->Read(GetPhysicalWorld(), FALSE,
|
|
world, time, total) && // lit le monde
|
|
!m_bAccessBuild &&
|
|
!m_bPrivate )
|
|
{
|
|
m_tryInsertCount = 40;
|
|
m_tryPhase = m_phase;
|
|
return ChangePhase(WM_PHASE_INSERT); // insérez le CD-Rom ...
|
|
}
|
|
m_pDecor->SetTime(0);
|
|
m_pDecor->SetTotalTime(0);
|
|
m_pDecor->SetInvincible(FALSE);
|
|
m_pDecor->SetSuper(FALSE);
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_INFO ||
|
|
m_phase == WM_PHASE_STOP ||
|
|
m_phase == WM_PHASE_HELP ||
|
|
m_phase == WM_PHASE_HISTORY0 ||
|
|
m_phase == WM_PHASE_HISTORY1 )
|
|
{
|
|
if ( m_bPrivate )
|
|
{
|
|
PrivateLibelle();
|
|
}
|
|
else if ( m_phase == WM_PHASE_INFO ||
|
|
m_phase == WM_PHASE_STOP )
|
|
{
|
|
if ( m_bSchool )
|
|
{
|
|
ReadLibelle(GetWorld(), m_bSchool, FALSE);
|
|
}
|
|
else
|
|
{
|
|
ReadLibelle(GetWorld()+2, m_bSchool, FALSE);
|
|
}
|
|
}
|
|
else if ( m_phase == WM_PHASE_HELP )
|
|
{
|
|
ReadLibelle(GetWorld(), FALSE, TRUE);
|
|
}
|
|
else
|
|
{
|
|
if ( m_phase == WM_PHASE_HISTORY0 ) world = 0;
|
|
else world = 1;
|
|
ReadLibelle(world, FALSE, FALSE);
|
|
}
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_TESTCD )
|
|
{
|
|
if ( m_pDecor->Read(0, FALSE, world, time, total) ) // lit un monde
|
|
{
|
|
return ChangePhase(WM_PHASE_INIT); // ok
|
|
}
|
|
else
|
|
{
|
|
m_tryInsertCount = 40;
|
|
m_tryPhase = m_phase;
|
|
return ChangePhase(WM_PHASE_INSERT); // insérez le CD-Rom ...
|
|
}
|
|
}
|
|
|
|
m_jauges[0].SetHide(TRUE); // cache les jauges
|
|
m_jauges[1].SetHide(TRUE);
|
|
CreateButtons(); // crée les boutons selon la phase
|
|
m_bMenu = FALSE;
|
|
m_pDecor->HideTooltips(FALSE);
|
|
m_menu.Delete();
|
|
m_pDecor->BlupiSetArrow(0, FALSE); // enlève toutes les flèches
|
|
m_pDecor->ResetHili(); // enlève les mises en évidence
|
|
|
|
if ( m_phase == WM_PHASE_PLAY )
|
|
{
|
|
m_pDecor->LoadImages();
|
|
m_pDecor->SetBuild(FALSE);
|
|
m_pDecor->EnableFog(TRUE);
|
|
m_pDecor->NextPhase(0); // refait la carte tout de suite
|
|
m_pDecor->StatisticInit();
|
|
m_pDecor->TerminatedInit();
|
|
m_bChangeCheat = TRUE; // affiche les cheat-codes
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_BUILD )
|
|
{
|
|
m_bBuildModify = TRUE;
|
|
SetState(WM_DECOR1, 1);
|
|
SetMenu(WM_DECOR1, 0); // herbe
|
|
SetMenu(WM_DECOR2, 2); // arbre
|
|
SetMenu(WM_DECOR3, 1); // maison
|
|
SetMenu(WM_DECOR4, 2); // blupi fort
|
|
SetMenu(WM_DECOR5, 1); // feu
|
|
m_pDecor->LoadImages();
|
|
m_pDecor->SetBuild(TRUE);
|
|
m_pDecor->EnableFog(FALSE);
|
|
m_pDecor->BlupiDeselect();
|
|
m_pDecor->NextPhase(0); // refait la carte tout de suite
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_INFO )
|
|
{
|
|
bEnable = TRUE;
|
|
if ( GetWorld() == 0 )
|
|
{
|
|
bEnable = FALSE;
|
|
}
|
|
SetEnable(WM_PREV, bEnable);
|
|
|
|
bEnable = TRUE;
|
|
if ( m_bAllMissions ) max = 99;
|
|
else max = m_maxMission;
|
|
if ( !m_bSchool &&
|
|
GetWorld() >= max )
|
|
{
|
|
bEnable = FALSE;
|
|
}
|
|
if ( !m_pDecor->FileExist(GetPhysicalWorld()+1, FALSE,
|
|
world, time, total) )
|
|
{
|
|
bEnable = FALSE;
|
|
}
|
|
#if !_DEMO
|
|
if ( m_bAccessBuild ||
|
|
m_pDecor->GetTotalTime() > DEF_TIME_HELP*6 )
|
|
{
|
|
bEnable = TRUE;
|
|
}
|
|
#endif
|
|
if ( GetWorld() >= 99 )
|
|
{
|
|
bEnable = FALSE;
|
|
}
|
|
#if _DEMO
|
|
if ( GetWorld() >= 4-1 )
|
|
{
|
|
bEnable = FALSE;
|
|
}
|
|
#endif
|
|
if ( m_bPrivate )
|
|
{
|
|
bEnable = GetWorld()<20-1;
|
|
}
|
|
SetEnable(WM_NEXT, bEnable);
|
|
|
|
bHide = TRUE;
|
|
if ( m_bAccessBuild || m_bPrivate )
|
|
{
|
|
bHide = FALSE;
|
|
}
|
|
SetHide(WM_PHASE_BUILD, bHide);
|
|
|
|
#if !_DEMO
|
|
if ( m_bSchool )
|
|
{
|
|
SetHide(WM_PHASE_SKILL1, TRUE);
|
|
SetHide(WM_PHASE_SKILL2, TRUE);
|
|
}
|
|
else
|
|
{
|
|
SetState(WM_PHASE_SKILL1, m_pDecor->GetSkill()==0?1:0);
|
|
SetState(WM_PHASE_SKILL2, m_pDecor->GetSkill()==1?1:0);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_STOP )
|
|
{
|
|
SetHide(WM_PHASE_HELP, IsHelpHide());
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_READ )
|
|
{
|
|
for ( i=0 ; i<10 ; i++ )
|
|
{
|
|
if ( m_fileWorld[i] == -1 )
|
|
{
|
|
SetEnable(WM_READ0+i, FALSE);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_BUTTON )
|
|
{
|
|
pButtonExist = m_pDecor->GetButtonExist();
|
|
|
|
for ( i=0 ; i<MAXBUTTON ; i++ )
|
|
{
|
|
SetState(WM_BUTTON0+i, pButtonExist[i]);
|
|
}
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_TERM )
|
|
{
|
|
pTerm = m_pDecor->GetTerminated();
|
|
|
|
SetState(WM_BUTTON1, pTerm->bHachBlupi?1:0);
|
|
SetState(WM_BUTTON2, pTerm->bHachPlanche?1:0);
|
|
SetState(WM_BUTTON3, pTerm->bStopFire?1:0);
|
|
SetState(WM_BUTTON8, pTerm->bHomeBlupi?1:0);
|
|
SetState(WM_BUTTON9, pTerm->bKillRobots?1:0);
|
|
SetState(WM_BUTTON10, pTerm->bHachTomate?1:0);
|
|
SetState(WM_BUTTON11, pTerm->bHachMetal?1:0);
|
|
SetState(WM_BUTTON12, pTerm->bHachRobot?1:0);
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_MUSIC )
|
|
{
|
|
music = m_pDecor->GetMusic();
|
|
|
|
for ( i=0 ; i<10 ; i++ )
|
|
{
|
|
SetState(WM_BUTTON1+i, music==i?1:0);
|
|
}
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_REGION )
|
|
{
|
|
music = m_pDecor->GetRegion();
|
|
|
|
for ( i=0 ; i<4 ; i++ )
|
|
{
|
|
SetState(WM_BUTTON1+i, music==i?1:0);
|
|
}
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_PLAY ||
|
|
m_phase == WM_PHASE_MUSIC )
|
|
{
|
|
if ( m_pSound->IsPlayingMusic() )
|
|
{
|
|
m_pSound->AdaptVolumeMusic(); // adapte le volume
|
|
}
|
|
else
|
|
{
|
|
music = m_pDecor->GetMusic();
|
|
if ( music > 0 )
|
|
{
|
|
sprintf(filename, "sound\\music%.3d.blp", music-1);
|
|
m_pSound->PlayMusic(m_hWnd, filename);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( phase == WM_PHASE_H0MOVIE )
|
|
{
|
|
strcpy(m_movieToStart, "movie\\history0.avi");
|
|
AddCDPath(m_movieToStart);
|
|
m_phaseAfterMovie = WM_PHASE_HISTORY0;
|
|
}
|
|
|
|
if ( phase == WM_PHASE_H1MOVIE )
|
|
{
|
|
strcpy(m_movieToStart, "movie\\history1.avi");
|
|
AddCDPath(m_movieToStart);
|
|
m_phaseAfterMovie = WM_PHASE_HISTORY1;
|
|
}
|
|
|
|
if ( phase == WM_PHASE_H2MOVIE )
|
|
{
|
|
strcpy(m_movieToStart, "movie\\history2.avi");
|
|
AddCDPath(m_movieToStart);
|
|
m_phaseAfterMovie = WM_PHASE_INFO;
|
|
}
|
|
|
|
if ( phase == WM_PHASE_PLAYMOVIE )
|
|
{
|
|
sprintf(m_movieToStart, "movie\\play%.3d.avi", GetPhysicalWorld());
|
|
AddCDPath(m_movieToStart);
|
|
m_phaseAfterMovie = WM_PHASE_PLAY;
|
|
}
|
|
|
|
if ( phase == WM_PHASE_WINMOVIE )
|
|
{
|
|
sprintf(m_movieToStart, "movie\\win%.3d.avi", GetPhysicalWorld());
|
|
AddCDPath(m_movieToStart);
|
|
m_phaseAfterMovie = WM_PHASE_WIN;
|
|
|
|
if ( !m_bPrivate &&
|
|
m_pDecor->FileExist(GetPhysicalWorld(),
|
|
FALSE, world, time, total) &&
|
|
!m_pDecor->FileExist(GetPhysicalWorld()+1,
|
|
FALSE, world, time, total) )
|
|
{
|
|
m_phaseAfterMovie = WM_PHASE_LASTWIN;
|
|
}
|
|
}
|
|
|
|
WaitMouse(FALSE); // enlève le sablier
|
|
return TRUE;
|
|
}
|
|
|
|
// Retourne la phase en cours.
|
|
|
|
UINT CEvent::GetPhase()
|
|
{
|
|
return m_phase;
|
|
}
|
|
|
|
// Essaye de lire le CD-Rom.
|
|
|
|
void CEvent::TryInsert()
|
|
{
|
|
if ( m_tryInsertCount == 0 )
|
|
{
|
|
ChangePhase(m_tryPhase);
|
|
}
|
|
else
|
|
{
|
|
m_tryInsertCount --;
|
|
}
|
|
}
|
|
|
|
// Fait démarrer un film si nécessaire.
|
|
|
|
void CEvent::MovieToStart()
|
|
{
|
|
if ( m_movieToStart[0] != 0 ) // y a-t-il un film à démarrer ?
|
|
{
|
|
HideMouse(TRUE); // cache la souris
|
|
|
|
if ( StartMovie(m_movieToStart) )
|
|
{
|
|
m_phase = m_phaseAfterMovie; // prochaine phase normale
|
|
}
|
|
else
|
|
{
|
|
ChangePhase(m_phaseAfterMovie);
|
|
}
|
|
|
|
m_movieToStart[0] = 0;
|
|
}
|
|
}
|
|
|
|
|
|
// Décale le décor.
|
|
|
|
void CEvent::DecorShift(int dx, int dy)
|
|
{
|
|
POINT coin;
|
|
|
|
if ( m_phase != WM_PHASE_PLAY &&
|
|
m_phase != WM_PHASE_BUILD ) return;
|
|
|
|
coin = m_pDecor->GetCoin();
|
|
|
|
coin.x += dx;
|
|
coin.y += dy;
|
|
|
|
m_pDecor->SetCoin(coin);
|
|
//? m_pDecor->NextPhase(0); // faudra refaire la carte tout de suite
|
|
}
|
|
|
|
// Décale le décor lorsque la souris touche un bord.
|
|
|
|
void CEvent::DecorAutoShift(POINT pos)
|
|
{
|
|
int max;
|
|
POINT offset;
|
|
|
|
m_bShift = FALSE;
|
|
|
|
if ( !m_bFullScreen ||
|
|
m_bDemoRec ||
|
|
m_bDemoPlay ||
|
|
m_scrollSpeed == 0 ) return;
|
|
|
|
max = 4-m_scrollSpeed; // max <- 3..1
|
|
|
|
//? if ( m_bMousePress &&
|
|
//? (m_phase == WM_PHASE_PLAY ||
|
|
//? m_phase == WM_PHASE_BUILD) )
|
|
if ( m_phase == WM_PHASE_PLAY ||
|
|
m_phase == WM_PHASE_BUILD )
|
|
{
|
|
if ( m_shiftPhase == 0 ) // début du shift ?
|
|
{
|
|
m_shiftOffset.x = 0;
|
|
m_shiftOffset.y = 0;
|
|
m_shiftVector.x = 0;
|
|
m_shiftVector.y = 0;
|
|
|
|
if ( m_mouseSprite == SPRITE_ARROWL )
|
|
{
|
|
m_shiftOffset.x = +2;
|
|
m_shiftOffset.y = 0;
|
|
m_shiftVector.x = -1;
|
|
m_shiftVector.y = +1;
|
|
}
|
|
|
|
if ( m_mouseSprite == SPRITE_ARROWR )
|
|
{
|
|
m_shiftOffset.x = -2;
|
|
m_shiftOffset.y = 0;
|
|
m_shiftVector.x = +1;
|
|
m_shiftVector.y = -1;
|
|
}
|
|
|
|
if ( m_mouseSprite == SPRITE_ARROWU )
|
|
{
|
|
m_shiftOffset.x = 0;
|
|
m_shiftOffset.y = +2;
|
|
m_shiftVector.x = -1;
|
|
m_shiftVector.y = -1;
|
|
}
|
|
|
|
if ( m_mouseSprite == SPRITE_ARROWD )
|
|
{
|
|
m_shiftOffset.x = 0;
|
|
m_shiftOffset.y = -2;
|
|
m_shiftVector.x = +1;
|
|
m_shiftVector.y = +1;
|
|
}
|
|
|
|
if ( m_mouseSprite == SPRITE_ARROWUL )
|
|
{
|
|
m_shiftOffset.x = +1;
|
|
m_shiftOffset.y = +1;
|
|
m_shiftVector.x = -1;
|
|
m_shiftVector.y = 0;
|
|
}
|
|
|
|
if ( m_mouseSprite == SPRITE_ARROWUR )
|
|
{
|
|
m_shiftOffset.x = -1;
|
|
m_shiftOffset.y = +1;
|
|
m_shiftVector.x = 0;
|
|
m_shiftVector.y = -1;
|
|
}
|
|
|
|
if ( m_mouseSprite == SPRITE_ARROWDL )
|
|
{
|
|
m_shiftOffset.x = +1;
|
|
m_shiftOffset.y = -1;
|
|
m_shiftVector.x = 0;
|
|
m_shiftVector.y = +1;
|
|
}
|
|
|
|
if ( m_mouseSprite == SPRITE_ARROWDR )
|
|
{
|
|
m_shiftOffset.x = -1;
|
|
m_shiftOffset.y = -1;
|
|
m_shiftVector.x = +1;
|
|
m_shiftVector.y = 0;
|
|
}
|
|
|
|
if ( m_shiftVector.x != 0 ||
|
|
m_shiftVector.y != 0 )
|
|
{
|
|
m_shiftPhase = max;
|
|
}
|
|
}
|
|
|
|
if ( m_shiftPhase > 0 )
|
|
{
|
|
m_bShift = TRUE;
|
|
m_shiftPhase --;
|
|
|
|
offset.x = m_shiftOffset.x*(max-m_shiftPhase)*(DIMCELX/2/max);
|
|
offset.y = m_shiftOffset.y*(max-m_shiftPhase)*(DIMCELY/2/max);
|
|
m_pDecor->SetShiftOffset(offset);
|
|
|
|
if ( m_shiftPhase == 0 ) // dernière phase ?
|
|
{
|
|
offset.x = 0;
|
|
offset.y = 0;
|
|
m_pDecor->SetShiftOffset(offset);
|
|
DecorShift(m_shiftVector.x, m_shiftVector.y);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Indique su un shift est en cours.
|
|
|
|
BOOL CEvent::IsShift()
|
|
{
|
|
return m_bShift;
|
|
}
|
|
|
|
|
|
// Modifie le décor lorsque le bouton de la souris est pressé.
|
|
|
|
BOOL CEvent::PlayDown(POINT pos, int fwKeys)
|
|
{
|
|
BOOL bDecor = FALSE;
|
|
BOOL bMap = FALSE;
|
|
int rank, button, h;
|
|
POINT cel;
|
|
|
|
m_pDecor->BlupiSetArrow(0, FALSE); // enlève toutes les flèches
|
|
|
|
m_bMouseDown = FALSE;
|
|
|
|
if ( m_bMenu )
|
|
{
|
|
m_menu.Message();
|
|
m_bMenu = FALSE;
|
|
m_pDecor->HideTooltips(FALSE);
|
|
m_menu.Delete();
|
|
return TRUE;
|
|
}
|
|
|
|
m_pDecor->StatisticDown(pos, fwKeys);
|
|
|
|
if ( pos.x >= POSMAPX && pos.x <= POSMAPX+DIMMAPX &&
|
|
pos.y >= POSMAPY && pos.y <= POSMAPY+DIMMAPY )
|
|
{
|
|
bMap = TRUE;
|
|
}
|
|
h = m_pDecor->GetInfoHeight()+POSDRAWY;
|
|
if ( pos.x >= POSDRAWX && pos.x <= POSDRAWX+DIMDRAWX &&
|
|
pos.y >= h && pos.y <= h +DIMDRAWY )
|
|
{
|
|
bDecor = TRUE;
|
|
}
|
|
|
|
if ( !bDecor && !bMap ) return FALSE;
|
|
|
|
cel = m_pDecor->ConvPosToCel(pos, TRUE);
|
|
if ( fwKeys&MK_RBUTTON )
|
|
{
|
|
if ( bMap )
|
|
{
|
|
button = BUTTON_GO;
|
|
}
|
|
else
|
|
{
|
|
button = m_pDecor->GetDefButton(cel);
|
|
}
|
|
m_pDecor->BlupiGoal(cel, button);
|
|
return TRUE;
|
|
}
|
|
|
|
if ( bMap )
|
|
{
|
|
m_pDecor->SetCoin(cel, TRUE);
|
|
m_pDecor->NextPhase(0); // faudra refaire la carte tout de suite
|
|
return TRUE;
|
|
}
|
|
|
|
rank = m_pDecor->GetTargetBlupi(pos);
|
|
if ( rank >= 0 &&
|
|
!m_pDecor->IsWorkBlupi(rank) )
|
|
{
|
|
m_bHili = TRUE;
|
|
m_bMouseDown = TRUE;
|
|
m_pDecor->BlupiHiliDown(pos, fwKeys&MK_SHIFT);
|
|
}
|
|
else
|
|
{
|
|
m_bHili = FALSE;
|
|
m_bMouseDown = TRUE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// Modifie le décor lorsque la souris est déplacée.
|
|
|
|
BOOL CEvent::PlayMove(POINT pos, int fwKeys)
|
|
{
|
|
if ( m_bMenu )
|
|
{
|
|
if ( !m_menu.IsExist() )
|
|
{
|
|
m_bMenu = FALSE;
|
|
m_pDecor->HideTooltips(FALSE);
|
|
m_menu.Delete();
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
m_pDecor->StatisticMove(pos, fwKeys);
|
|
|
|
if ( m_bMouseDown ) // bouton souris pressé ?
|
|
{
|
|
if ( m_bHili )
|
|
{
|
|
m_pDecor->BlupiHiliMove(pos, fwKeys&MK_SHIFT);
|
|
}
|
|
else
|
|
{
|
|
m_pDecor->CelHili(pos, 0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_pDecor->CelHili(pos, 0);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// Modifie le décor lorsque le bouton de la souris est relâché.
|
|
|
|
BOOL CEvent::PlayUp(POINT pos, int fwKeys)
|
|
{
|
|
static int table_sound_boing[3] =
|
|
{
|
|
SOUND_BOING1,
|
|
SOUND_BOING2,
|
|
SOUND_BOING3,
|
|
};
|
|
|
|
m_pDecor->StatisticUp(pos, fwKeys);
|
|
|
|
if ( m_bMouseDown ) // bouton souris pressé ?
|
|
{
|
|
if ( m_bHili )
|
|
{
|
|
m_pDecor->BlupiHiliUp(pos, fwKeys&MK_SHIFT);
|
|
}
|
|
else
|
|
{
|
|
m_pDecor->BlupiGetButtons(pos, m_menuNb, m_menuButtons,
|
|
m_menuErrors, m_menuPerso);
|
|
if ( m_menuNb == 0 )
|
|
{
|
|
m_pDecor->BlupiSound(-1, table_sound_boing[Random(0,2)], pos);
|
|
}
|
|
else
|
|
{
|
|
m_menuCel = m_pDecor->ConvPosToCel(pos);
|
|
m_menuPos = pos;
|
|
m_menu.Create(m_hWnd, m_pPixmap, m_pSound,
|
|
pos, m_menuNb, m_menuButtons, m_menuErrors,
|
|
m_menuPerso);
|
|
m_bMenu = TRUE;
|
|
m_pDecor->HideTooltips(TRUE); // plus de tooltips pour décor
|
|
}
|
|
}
|
|
}
|
|
|
|
m_bMouseDown = FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// Clic dans un bouton.
|
|
// Message = WM_BUTTON0..WM_BUTTON39
|
|
|
|
void CEvent::ChangeButtons(int message)
|
|
{
|
|
int button, state, volume, max;
|
|
char* pButtonExist;
|
|
Term* pTerm;
|
|
|
|
if ( m_phase == WM_PHASE_PLAY )
|
|
{
|
|
button = m_menuButtons[message-WM_BUTTON0];
|
|
m_pDecor->BlupiGoal(m_menuCel, button);
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_BUTTON )
|
|
{
|
|
pButtonExist = m_pDecor->GetButtonExist();
|
|
|
|
state = GetState(message);
|
|
if ( state == 0 ) state = 1;
|
|
else state = 0;
|
|
SetState(message, state); // pressé <-> relâché
|
|
|
|
pButtonExist[message-WM_BUTTON0] = state;
|
|
pButtonExist[BUTTON_DJEEP] = TRUE;
|
|
pButtonExist[BUTTON_DARMURE] = TRUE;
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_TERM )
|
|
{
|
|
pTerm = m_pDecor->GetTerminated();
|
|
|
|
if ( message == WM_BUTTON1 ||
|
|
message == WM_BUTTON2 ||
|
|
message == WM_BUTTON3 ||
|
|
message == WM_BUTTON8 ||
|
|
message == WM_BUTTON9 ||
|
|
message == WM_BUTTON10 ||
|
|
message == WM_BUTTON11 ||
|
|
message == WM_BUTTON12 )
|
|
{
|
|
state = GetState(message);
|
|
if ( state == 0 ) state = 1;
|
|
else state = 0;
|
|
SetState(message, state); // pressé <-> relâché
|
|
|
|
if ( message == WM_BUTTON1 ) pTerm->bHachBlupi = state;
|
|
if ( message == WM_BUTTON2 ) pTerm->bHachPlanche = state;
|
|
if ( message == WM_BUTTON3 ) pTerm->bStopFire = state;
|
|
if ( message == WM_BUTTON8 ) pTerm->bHomeBlupi = state;
|
|
if ( message == WM_BUTTON9 ) pTerm->bKillRobots = state;
|
|
if ( message == WM_BUTTON10 ) pTerm->bHachTomate = state;
|
|
if ( message == WM_BUTTON11 ) pTerm->bHachMetal = state;
|
|
if ( message == WM_BUTTON12 ) pTerm->bHachRobot = state;
|
|
}
|
|
|
|
if ( message == WM_BUTTON4 )
|
|
{
|
|
if ( pTerm->nbMinBlupi > 1 ) pTerm->nbMinBlupi --;
|
|
}
|
|
if ( message == WM_BUTTON5 )
|
|
{
|
|
if ( pTerm->nbMinBlupi < 100 ) pTerm->nbMinBlupi ++;
|
|
}
|
|
|
|
if ( message == WM_BUTTON6 )
|
|
{
|
|
if ( pTerm->nbMaxBlupi > 1 ) pTerm->nbMaxBlupi --;
|
|
}
|
|
if ( message == WM_BUTTON7 )
|
|
{
|
|
if ( pTerm->nbMaxBlupi < 100 ) pTerm->nbMaxBlupi ++;
|
|
}
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_MUSIC )
|
|
{
|
|
m_pDecor->SetMusic(message-WM_BUTTON1);
|
|
ChangePhase(m_phase);
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_REGION )
|
|
{
|
|
m_pDecor->SetRegion(message-WM_BUTTON1);
|
|
ChangePhase(WM_PHASE_BUILD);
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_SETUP ||
|
|
m_phase == WM_PHASE_SETUPp )
|
|
{
|
|
if ( message == WM_BUTTON1 )
|
|
{
|
|
if ( m_speed > 1 )
|
|
{
|
|
m_speed = m_speed>>1;
|
|
}
|
|
}
|
|
if ( message == WM_BUTTON2 )
|
|
{
|
|
if ( m_bSpeed ) max = 8;
|
|
else max = 2;
|
|
if ( m_speed < max )
|
|
{
|
|
m_speed = m_speed<<1;
|
|
}
|
|
}
|
|
|
|
if ( message == WM_BUTTON3 )
|
|
{
|
|
volume = m_pSound->GetAudioVolume();
|
|
if ( volume > 0 )
|
|
{
|
|
m_pSound->SetAudioVolume(volume-1);
|
|
}
|
|
}
|
|
if ( message == WM_BUTTON4 )
|
|
{
|
|
volume = m_pSound->GetAudioVolume();
|
|
if ( volume < MAXVOLUME )
|
|
{
|
|
m_pSound->SetAudioVolume(volume+1);
|
|
}
|
|
}
|
|
|
|
if ( message == WM_BUTTON5 )
|
|
{
|
|
volume = m_pSound->GetMidiVolume();
|
|
if ( volume > 0 )
|
|
{
|
|
m_pSound->SetMidiVolume(volume-1);
|
|
m_pSound->SuspendMusic();
|
|
}
|
|
}
|
|
if ( message == WM_BUTTON6 )
|
|
{
|
|
volume = m_pSound->GetMidiVolume();
|
|
if ( volume < MAXVOLUME )
|
|
{
|
|
m_pSound->SetMidiVolume(volume+1);
|
|
m_pSound->SuspendMusic();
|
|
}
|
|
}
|
|
|
|
if ( message == WM_BUTTON7 )
|
|
{
|
|
m_bMovie = FALSE;
|
|
}
|
|
if ( message == WM_BUTTON8 )
|
|
{
|
|
m_bMovie = TRUE;
|
|
}
|
|
|
|
if ( message == WM_BUTTON9 )
|
|
{
|
|
if ( m_scrollSpeed > 0 )
|
|
{
|
|
m_scrollSpeed --;
|
|
}
|
|
}
|
|
if ( message == WM_BUTTON10 )
|
|
{
|
|
if ( m_scrollSpeed < 3 )
|
|
{
|
|
m_scrollSpeed ++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// Met un sol si nécessaire sous un objet.
|
|
|
|
void CEvent::BuildFloor(POINT cel, int insIcon)
|
|
{
|
|
int iFloor, channel, icon;
|
|
|
|
if ( insIcon == -1 ) return; // supprime ?
|
|
|
|
if ( insIcon < 6 || // petite plante ?
|
|
insIcon == 117 ) // bateau ?
|
|
{
|
|
return;
|
|
}
|
|
|
|
iFloor = 1; // herbe
|
|
|
|
if ( insIcon == 28 || // laboratoire ?
|
|
insIcon == 61 || // cabane de jardin ?
|
|
insIcon == 113 || // maison ?
|
|
insIcon == 120 ) // usine ?
|
|
{
|
|
iFloor = 16; // sol brun foncé
|
|
}
|
|
|
|
if ( insIcon == 122 ) // mine de fer ?
|
|
{
|
|
iFloor = 71; // sol avec minerai
|
|
}
|
|
|
|
if ( insIcon == 99 || // station de recharge ?
|
|
insIcon == 100 || // usine ennemie ?
|
|
insIcon == 102 || // usine ennemie ?
|
|
insIcon == 104 || // usine ennemie ?
|
|
(insIcon >= 106 && insIcon <= 112) || // barrière ?
|
|
insIcon == 115 || // usine ennemie ?
|
|
insIcon == 17 || // usine ennemie ?
|
|
insIcon == 12 ) // fusée ?
|
|
{
|
|
iFloor = 67; // sol bleu ennemi
|
|
}
|
|
|
|
m_pDecor->GetFloor(cel, channel, icon);
|
|
if ( (channel == CHFLOOR &&
|
|
icon >= 2 && icon <= 14) || // eau ou rive ?
|
|
iFloor != 1 )
|
|
{
|
|
m_pDecor->PutFloor(cel, CHFLOOR, iFloor); // met un sol
|
|
m_pDecor->ArrangeFloor(cel);
|
|
}
|
|
}
|
|
|
|
// Enlève si nécessaire un objet sur l'eau.
|
|
|
|
void CEvent::BuildWater(POINT cel, int insIcon)
|
|
{
|
|
int channel, icon;
|
|
|
|
if ( insIcon != 14 ) return; // rien à faire si pas eau
|
|
|
|
m_pDecor->GetObject(cel, channel, icon);
|
|
if ( channel == CHOBJECT &&
|
|
icon >= 6 && // objet (pas petite plante) ?
|
|
icon != 117 ) // pas bateau ?
|
|
{
|
|
m_pDecor->PutObject(cel, -1, -1); // enlève l'objet
|
|
m_pDecor->ArrangeObject(cel);
|
|
}
|
|
}
|
|
|
|
// Cette table donne les objets à construire en fonction
|
|
// du choix dans le menu.
|
|
|
|
static int tableFloor[] =
|
|
{
|
|
1,49,50,51,0,0,0,0,0,0, // 0 herbe
|
|
20,66,79,0,0,0,0,0,0,0, // 1 foncé
|
|
33,46,47,48,71,0,0,0,0,0, // 2 terre
|
|
14,0,0,0,0,0,0,0,0,0, // 3 mer
|
|
15,16,17,18,19,65,67,0,0,0, // 4 dalles
|
|
52,80,0,0,0,0,0,0,0,0, // 5 couveuse
|
|
};
|
|
|
|
static int tableObject[] =
|
|
{
|
|
-1,0,0,0,0,0,0,0,0,0, // 0 détruit
|
|
0,4,1,2,3,5,0,0,0,0, // 1 plantes
|
|
6,7,8,9,10,11,0,0,0,0, // 2 arbres
|
|
81,83,94,0,0,0,0,0,0,0, // 5 fleurs
|
|
};
|
|
|
|
static int tableHome[] =
|
|
{
|
|
-1,0,0,0,0,0,0,0,0,0, // 0 détruit
|
|
113,61,28,120,0,0,0,0,0,0, // 1 maison
|
|
27,0,0,0,0,0,0,0,0,0, // 2 tour de protection
|
|
122,0,0,0,0,0,0,0,0,0, // 3 mine de fer
|
|
99,100,102,104,115,17,12,0,0,0, // 4 ennemi
|
|
112,0,0,0,0,0,0,0,0,0, // 5 barrière
|
|
26,71,0,0,0,0,0,0,0,0, // 6 palissade
|
|
37,38,39,40,41,42,43,0,0,0, // 7 rochers
|
|
36,44,60,63,80,123,14,0,0,0, // 8 matières
|
|
85,125,93,92,0,0,0,0,0,0, // 9 pièges
|
|
117,118,16,0,0,0,0,0,0,0, // 10 véhicules
|
|
};
|
|
|
|
// Modifie le décor lorsque le bouton de la souris est pressé.
|
|
|
|
BOOL CEvent::BuildDown(POINT pos, int fwKeys, BOOL bMix)
|
|
{
|
|
POINT cel;
|
|
int menu, channel, icon;
|
|
|
|
if ( bMix && m_pDecor->MapMove(pos) ) return TRUE;
|
|
|
|
if ( pos.x < POSDRAWX || pos.x > POSDRAWX+DIMDRAWX ||
|
|
pos.y < POSDRAWY || pos.y > POSDRAWY+DIMDRAWY ) return FALSE;
|
|
|
|
if ( bMix )
|
|
{
|
|
m_pDecor->UndoCopy(); // copie le décor pour undo év.
|
|
}
|
|
|
|
if ( GetState(WM_DECOR1) == 1 ) // pose d'un sol
|
|
{
|
|
cel = m_pDecor->ConvPosToCel2(pos);
|
|
menu = GetMenu(WM_DECOR1);
|
|
|
|
if ( !m_pDecor->GetFloor(cel, channel, icon) ) return FALSE;
|
|
|
|
if ( bMix && tableFloor[menu*10+m_lastFloor[menu]] == icon )
|
|
{
|
|
m_lastFloor[menu] ++;
|
|
if ( tableFloor[menu*10+m_lastFloor[menu]] == 0 )
|
|
{
|
|
m_lastFloor[menu] = 0;
|
|
}
|
|
}
|
|
|
|
if ( fwKeys & MK_CONTROL ) // touche Ctrl enfoncée ?
|
|
{
|
|
WaitMouse(TRUE);
|
|
m_pDecor->ArrangeFill(cel, CHFLOOR, tableFloor[menu*10+m_lastFloor[menu]], TRUE);
|
|
WaitMouse(FALSE);
|
|
}
|
|
else
|
|
{
|
|
icon = tableFloor[menu*10+m_lastFloor[menu]];
|
|
if ( menu >= 1 ) // met un sol ?
|
|
{
|
|
BuildWater(cel, icon); // enlève les objets
|
|
}
|
|
m_pDecor->PutFloor(cel, CHFLOOR, icon);
|
|
m_pDecor->ArrangeFloor(cel);
|
|
}
|
|
}
|
|
|
|
if ( GetState(WM_DECOR2) == 1 ) // pose d'un objet
|
|
{
|
|
cel = m_pDecor->ConvPosToCel2(pos);
|
|
menu = GetMenu(WM_DECOR2);
|
|
|
|
if ( !m_pDecor->GetObject(cel, channel, icon) ) return FALSE;
|
|
|
|
if ( bMix && tableObject[menu*10+m_lastObject[menu]] == icon )
|
|
{
|
|
m_lastObject[menu] ++;
|
|
if ( tableObject[menu*10+m_lastObject[menu]] == 0 )
|
|
{
|
|
m_lastObject[menu] = 0;
|
|
}
|
|
}
|
|
|
|
if ( fwKeys & MK_CONTROL ) // touche Ctrl enfoncée ?
|
|
{
|
|
WaitMouse(TRUE);
|
|
m_pDecor->ArrangeFill(cel, CHOBJECT, tableObject[menu*10+m_lastObject[menu]], FALSE);
|
|
WaitMouse(FALSE);
|
|
}
|
|
else
|
|
{
|
|
icon = tableObject[menu*10+m_lastObject[menu]];
|
|
BuildFloor(cel, icon); // met un sol si nécessaire
|
|
m_pDecor->PutObject(cel, CHOBJECT, icon);
|
|
m_pDecor->ArrangeObject(cel);
|
|
}
|
|
}
|
|
|
|
if ( GetState(WM_DECOR3) == 1 ) // pose d'un batiment
|
|
{
|
|
cel = m_pDecor->ConvPosToCel2(pos);
|
|
menu = GetMenu(WM_DECOR3);
|
|
|
|
if ( !m_pDecor->GetObject(cel, channel, icon) ) return FALSE;
|
|
|
|
if ( bMix && tableHome[menu*10+m_lastHome[menu]] == icon )
|
|
{
|
|
m_lastHome[menu] ++;
|
|
if ( tableHome[menu*10+m_lastHome[menu]] == 0 )
|
|
{
|
|
m_lastHome[menu] = 0;
|
|
}
|
|
}
|
|
|
|
if ( fwKeys & MK_CONTROL ) // touche Ctrl enfoncée ?
|
|
{
|
|
WaitMouse(TRUE);
|
|
m_pDecor->ArrangeFill(cel, CHOBJECT, tableHome[menu*10+m_lastHome[menu]], FALSE);
|
|
WaitMouse(FALSE);
|
|
}
|
|
else
|
|
{
|
|
icon = tableHome[menu*10+m_lastHome[menu]];
|
|
BuildFloor(cel, icon); // met un sol si nécessaire
|
|
m_pDecor->PutObject(cel, CHOBJECT, icon);
|
|
m_pDecor->ArrangeObject(cel);
|
|
}
|
|
}
|
|
|
|
if ( GetState(WM_DECOR4) == 1 ) // pose d'un blupi
|
|
{
|
|
cel = m_pDecor->ConvPosToCel(pos);
|
|
menu = GetMenu(WM_DECOR4);
|
|
|
|
if ( menu == 0 ) // supprime ?
|
|
{
|
|
m_pDecor->BlupiDelete(cel);
|
|
}
|
|
if ( menu == 1 ) // ajoute blupi-fatigué ?
|
|
{
|
|
m_pDecor->BlupiCreate(cel, ACTION_STOP, DIRECT_S, 0, MAXENERGY/4);
|
|
}
|
|
if ( menu == 2 ) // ajoute blupi-énergique ?
|
|
{
|
|
m_pDecor->BlupiCreate(cel, ACTION_STOP, DIRECT_S, 0, MAXENERGY);
|
|
}
|
|
if ( menu == 3 ) // ajoute assistant ?
|
|
{
|
|
m_pDecor->BlupiCreate(cel, ACTION_STOP, DIRECT_S, 8, MAXENERGY);
|
|
}
|
|
if ( menu == 4 ) // ajoute araignée ?
|
|
{
|
|
m_pDecor->BlupiCreate(cel, ACTION_STOP, DIRECT_S, 1, MAXENERGY);
|
|
}
|
|
if ( menu == 5 ) // ajoute virus ?
|
|
{
|
|
m_pDecor->BlupiCreate(cel, ACTION_STOP, DIRECT_S, 2, MAXENERGY);
|
|
}
|
|
if ( menu == 6 ) // ajoute tracks ?
|
|
{
|
|
m_pDecor->BlupiCreate(cel, ACTION_STOP, DIRECT_S, 3, MAXENERGY);
|
|
}
|
|
if ( menu == 7 ) // ajoute bombe ?
|
|
{
|
|
m_pDecor->BlupiCreate(cel, ACTION_STOP, DIRECT_S, 5, MAXENERGY);
|
|
}
|
|
if ( menu == 8 ) // ajoute électro ?
|
|
{
|
|
m_pDecor->BlupiCreate(cel, ACTION_STOP, DIRECT_S, 7, MAXENERGY);
|
|
}
|
|
if ( menu == 9 ) // ajoute robot ?
|
|
{
|
|
m_pDecor->BlupiCreate(cel, ACTION_STOP, DIRECT_S, 4, MAXENERGY);
|
|
}
|
|
}
|
|
|
|
if ( GetState(WM_DECOR5) == 1 ) // pose d'une cata
|
|
{
|
|
cel = m_pDecor->ConvPosToCel2(pos);
|
|
menu = GetMenu(WM_DECOR5);
|
|
|
|
if ( menu == 0 ) // supprime ?
|
|
{
|
|
m_pDecor->SetFire(cel, FALSE);
|
|
}
|
|
if ( menu == 1 ) // ajoute ?
|
|
{
|
|
m_pDecor->SetFire(cel, TRUE);
|
|
}
|
|
}
|
|
|
|
m_pDecor->ArrangeBlupi(); // supprime les blupi bloqués
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// Modifie le décor lorsque la souris est déplacée.
|
|
|
|
BOOL CEvent::BuildMove(POINT pos, int fwKeys)
|
|
{
|
|
if ( fwKeys & MK_LBUTTON ) // bouton souris pressé ?
|
|
{
|
|
BuildDown(pos, fwKeys, FALSE);
|
|
}
|
|
|
|
if ( GetState(WM_DECOR4) == 1 ) // pose d'un blupi
|
|
{
|
|
m_pDecor->CelHili(pos, 1);
|
|
}
|
|
else
|
|
{
|
|
m_pDecor->CelHili(pos, 2);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// Modifie le décor lorsque le bouton de la souris est relâché.
|
|
|
|
BOOL CEvent::BuildUp(POINT pos, int fwKeys)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// Démarre un film non interractif.
|
|
|
|
BOOL CEvent::StartMovie(char *pFilename)
|
|
{
|
|
RECT rect;
|
|
char filename[MAX_PATH];
|
|
|
|
if ( !m_pMovie->GetEnable() ) return FALSE;
|
|
if ( !m_bMovie ) return FALSE;
|
|
|
|
if ( !m_pMovie->IsExist(pFilename) ) return FALSE;
|
|
|
|
rect.left = 1; // mystère: plante avec 0,0,LXIMAGE,LYIMAGE !!!
|
|
rect.top = 1;
|
|
rect.right = LXIMAGE-2;
|
|
rect.bottom = LYIMAGE-2;
|
|
|
|
m_pSound->StopMusic();
|
|
m_pPixmap->SavePalette();
|
|
|
|
strcpy(filename, pFilename);
|
|
strcpy(filename+strlen(filename)-4, ".blp"); // remplace .avi par .blp
|
|
m_pSound->Cache(SOUND_MOVIE, filename);
|
|
|
|
if ( !m_pMovie->Play(m_hWnd, rect, pFilename) ) return FALSE;
|
|
m_bRunMovie = TRUE;
|
|
m_pSound->Play(SOUND_MOVIE, 0, 0);
|
|
return TRUE;
|
|
}
|
|
|
|
// Stoppe un film non interractif.
|
|
|
|
void CEvent::StopMovie()
|
|
{
|
|
m_pMovie->Stop(m_hWnd);
|
|
m_pPixmap->RestorePalette();
|
|
m_pPixmap->MouseInvalidate();
|
|
m_pSound->Flush(SOUND_MOVIE);
|
|
// m_pSound->RestartMusic();
|
|
ChangePhase(m_phase);
|
|
m_bRunMovie = FALSE;
|
|
}
|
|
|
|
// Indique s'il y a un film en cours.
|
|
|
|
BOOL CEvent::IsMovie()
|
|
{
|
|
return m_bRunMovie;
|
|
}
|
|
|
|
|
|
// Lit une partie (user000.blp).
|
|
|
|
void CEvent::Read(int message)
|
|
{
|
|
int world, time, total;
|
|
|
|
m_pDecor->Read(message-WM_READ0, TRUE, world, time, total);
|
|
m_pDecor->SetTime(time);
|
|
m_pDecor->SetTotalTime(total);
|
|
|
|
if ( world >= 200 )
|
|
{
|
|
m_private = world-200;
|
|
m_bSchool = FALSE;
|
|
m_bPrivate = TRUE;
|
|
}
|
|
else if ( world >= 100 )
|
|
{
|
|
m_mission = world-100;
|
|
m_bSchool = FALSE;
|
|
m_bPrivate = FALSE;
|
|
}
|
|
else
|
|
{
|
|
m_exercice = world;
|
|
m_bSchool = TRUE;
|
|
m_bPrivate = FALSE;
|
|
}
|
|
}
|
|
|
|
// Ecrit une partie (user000.blp).
|
|
|
|
void CEvent::Write(int message)
|
|
{
|
|
int time, total;
|
|
|
|
time = m_pDecor->GetTime();
|
|
total = m_pDecor->GetTotalTime();
|
|
|
|
m_pDecor->Write(message-WM_WRITE0, TRUE,
|
|
GetPhysicalWorld(), time, total);
|
|
}
|
|
|
|
|
|
// Initialise le libellé d'une mission privée.
|
|
|
|
void CEvent::PrivateLibelle()
|
|
{
|
|
int i, res, nb, h1, h2;
|
|
Term term;
|
|
char string[100];
|
|
char buffer[100];
|
|
|
|
LoadString(TX_PRIVATE_OBJECTIF, m_libelle, 100);
|
|
|
|
memcpy(&term, m_pDecor->GetTerminated(), sizeof(Term));
|
|
nb = 0;
|
|
for ( i=0 ; i<2 ; i++ ) // 2 objectifs au maximum !
|
|
{
|
|
res = 0;
|
|
if ( term.bKillRobots )
|
|
{
|
|
term.bKillRobots = FALSE;
|
|
res = TX_PRIVATE_KILLROBOTS;
|
|
}
|
|
else if ( term.bHachBlupi )
|
|
{
|
|
term.bHachBlupi = FALSE;
|
|
res = TX_PRIVATE_HACHBLUPI;
|
|
}
|
|
else if ( term.bHachPlanche )
|
|
{
|
|
term.bHachPlanche = FALSE;
|
|
res = TX_PRIVATE_HACHPLANCHE;
|
|
}
|
|
else if ( term.bHachTomate )
|
|
{
|
|
term.bHachTomate = FALSE;
|
|
res = TX_PRIVATE_HACHTOMATE;
|
|
}
|
|
else if ( term.bHachMetal )
|
|
{
|
|
term.bHachMetal = FALSE;
|
|
res = TX_PRIVATE_HACHMETAL;
|
|
}
|
|
else if ( term.bHachRobot )
|
|
{
|
|
term.bHachRobot = FALSE;
|
|
res = TX_PRIVATE_HACHROBOT;
|
|
}
|
|
else if ( term.bHomeBlupi )
|
|
{
|
|
term.bHomeBlupi = FALSE;
|
|
res = TX_PRIVATE_HOMEBLUPI;
|
|
}
|
|
else if ( term.bStopFire )
|
|
{
|
|
term.bStopFire = FALSE;
|
|
res = TX_PRIVATE_STOPFIRE;
|
|
}
|
|
if ( res == 0 ) break;
|
|
|
|
LoadString(res, string, 100);
|
|
strcat(m_libelle, "\n1|\n");
|
|
strcat(m_libelle, string);
|
|
nb ++;
|
|
}
|
|
|
|
if ( nb == 0 || term.nbMaxBlupi > 1 )
|
|
{
|
|
LoadString(TX_PRIVATE_NBBLUPI, buffer, 100);
|
|
sprintf(string, buffer, term.nbMaxBlupi);
|
|
strcat(m_libelle, "\n1|\n");
|
|
strcat(m_libelle, string);
|
|
}
|
|
|
|
h1 = GetTextHeight(m_libelle, FONTLITTLE, 1);
|
|
h2 = GetTextHeight(m_libelle, FONTLITTLE, 2);
|
|
if ( h2 > h1 ) h1 = h2;
|
|
m_pDecor->SetInfoHeight(POSDRAWY+h1+10);
|
|
}
|
|
|
|
// Lit le libellé d'un monde.
|
|
|
|
BOOL CEvent::ReadLibelle(int world, BOOL bSchool, BOOL bHelp)
|
|
{
|
|
FILE* file = NULL;
|
|
char* pBuffer = NULL;
|
|
char* pText;
|
|
char* pDest;
|
|
char indic;
|
|
int nb, h1, h2;
|
|
|
|
if ( bSchool ) indic = '$';
|
|
else indic = '#';
|
|
if ( bHelp ) indic = '@';
|
|
|
|
pBuffer = (char*)malloc(sizeof(char)*50000);
|
|
if ( pBuffer == NULL ) goto error;
|
|
memset(pBuffer, 0, sizeof(char)*50000);
|
|
|
|
file = fopen("data\\enigmes.blp", "rb");
|
|
if ( file == NULL ) goto error;
|
|
|
|
nb = fread(pBuffer, sizeof(char), 50000-1, file);
|
|
pBuffer[nb] = 0;
|
|
|
|
pText = pBuffer;
|
|
while ( world >= 0 )
|
|
{
|
|
while ( *pText != 0 && *pText != indic )
|
|
{
|
|
pText++;
|
|
}
|
|
if ( *pText == indic ) pText++;
|
|
world --;
|
|
}
|
|
while ( *pText != 0 && *pText != '\n' )
|
|
{
|
|
pText++;
|
|
}
|
|
if ( *pText == '\n' ) pText++;
|
|
pDest = m_libelle;
|
|
while ( *pText != 0 && *pText != indic &&
|
|
*pText != '$' && *pText != '#' && *pText != '@' )
|
|
{
|
|
*pDest++ = *pText++;
|
|
}
|
|
*pDest = 0;
|
|
|
|
h1 = GetTextHeight(m_libelle, FONTLITTLE, 1);
|
|
h2 = GetTextHeight(m_libelle, FONTLITTLE, 2);
|
|
if ( h2 > h1 ) h1 = h2;
|
|
m_pDecor->SetInfoHeight(POSDRAWY+h1+10);
|
|
|
|
free(pBuffer);
|
|
fclose(file);
|
|
return TRUE;
|
|
|
|
error:
|
|
if ( pBuffer != NULL ) free(pBuffer);
|
|
if ( file != NULL ) fclose(file);
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// Sauve les informations sur disque.
|
|
|
|
BOOL CEvent::WriteInfo()
|
|
{
|
|
char filename[MAX_PATH];
|
|
FILE* file = NULL;
|
|
DescInfo info;
|
|
int nb;
|
|
|
|
strcpy(filename, "data\\info.blp");
|
|
AddUserPath(filename);
|
|
|
|
file = fopen(filename, "wb");
|
|
if ( file == NULL ) goto error;
|
|
|
|
info.majRev = 1;
|
|
info.minRev = 0;
|
|
info.prive = m_private;
|
|
info.exercice = m_exercice;
|
|
info.mission = m_mission;
|
|
info.maxMission = m_maxMission;
|
|
info.speed = m_speed;
|
|
info.bMovie = m_bMovie;
|
|
info.scrollSpeed = m_scrollSpeed;
|
|
info.bAccessBuild = m_bAccessBuild;
|
|
|
|
info.skill = m_pDecor->GetSkill();
|
|
|
|
info.audioVolume = m_pSound->GetAudioVolume();
|
|
info.midiVolume = m_pSound->GetMidiVolume();
|
|
|
|
nb = fwrite(&info, sizeof(DescInfo), 1, file);
|
|
if ( nb < 1 ) goto error;
|
|
|
|
fclose(file);
|
|
return TRUE;
|
|
|
|
error:
|
|
if ( file != NULL ) fclose(file);
|
|
return FALSE;
|
|
}
|
|
|
|
// Lit les informations sur disque.
|
|
|
|
BOOL CEvent::ReadInfo()
|
|
{
|
|
char filename[MAX_PATH];
|
|
FILE* file = NULL;
|
|
DescInfo info;
|
|
int nb;
|
|
|
|
strcpy(filename, "data\\info.blp");
|
|
AddUserPath(filename);
|
|
|
|
file = fopen(filename, "rb");
|
|
if ( file == NULL ) goto error;
|
|
|
|
nb = fread(&info, sizeof(DescInfo), 1, file);
|
|
if ( nb < 1 ) goto error;
|
|
|
|
m_private = info.prive;
|
|
m_exercice = info.exercice;
|
|
m_mission = info.mission;
|
|
m_maxMission = info.maxMission;
|
|
m_speed = info.speed;
|
|
m_bMovie = info.bMovie;
|
|
m_scrollSpeed = info.scrollSpeed;
|
|
m_bAccessBuild = info.bAccessBuild;
|
|
|
|
m_pDecor->SetSkill(info.skill);
|
|
|
|
m_pSound->SetAudioVolume(info.audioVolume);
|
|
m_pSound->SetMidiVolume(info.midiVolume);
|
|
|
|
fclose(file);
|
|
return TRUE;
|
|
|
|
error:
|
|
if ( file != NULL ) fclose(file);
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// Modifie la vitesse du jeu.
|
|
|
|
void CEvent::SetSpeed(int speed)
|
|
{
|
|
int max;
|
|
|
|
if ( m_bSpeed ) max = 8;
|
|
else max = 2;
|
|
|
|
if ( speed > max ) speed = max;
|
|
|
|
m_speed = speed;
|
|
}
|
|
|
|
int CEvent::GetSpeed()
|
|
{
|
|
return m_speed;
|
|
}
|
|
|
|
BOOL CEvent::GetPause()
|
|
{
|
|
return m_bPause;
|
|
}
|
|
|
|
|
|
// Début de l'enregistrement d'une démo.
|
|
|
|
void CEvent::DemoRecStart()
|
|
{
|
|
m_pDemoBuffer = (DemoEvent*)malloc(MAXDEMO*sizeof(DemoEvent));
|
|
if ( m_pDemoBuffer == NULL ) return;
|
|
memset(m_pDemoBuffer, 0, MAXDEMO*sizeof(DemoEvent));
|
|
|
|
m_demoTime = 0;
|
|
m_demoIndex = 0;
|
|
m_bDemoRec = TRUE;
|
|
m_bDemoPlay = FALSE;
|
|
|
|
InitRandom();
|
|
m_pDecor->SetTime(0);
|
|
m_speed = 1;
|
|
}
|
|
|
|
// Fin de l'enregistrement d'une démo.
|
|
// Sauve le fichier sur disque.
|
|
|
|
void CEvent::DemoRecStop()
|
|
{
|
|
FILE* file = NULL;
|
|
DemoHeader header;
|
|
|
|
if ( m_bDemoPlay ) return;
|
|
|
|
if ( m_pDemoBuffer != NULL )
|
|
{
|
|
DeleteFile("data\\demo.blp");
|
|
file = fopen("data\\demo.blp", "wb");
|
|
if ( file != NULL )
|
|
{
|
|
memset(&header, 0, sizeof(DemoHeader));
|
|
header.majRev = 1;
|
|
header.minRev = 0;
|
|
header.bSchool = m_bSchool;
|
|
header.bPrivate = m_bPrivate;
|
|
header.world = GetPhysicalWorld();
|
|
header.skill = m_pDecor->GetSkill();
|
|
fwrite(&header, sizeof(DemoHeader), 1, file);
|
|
fwrite(m_pDemoBuffer, sizeof(DemoEvent), m_demoIndex, file);
|
|
fclose(file);
|
|
}
|
|
free(m_pDemoBuffer);
|
|
m_pDemoBuffer = NULL;
|
|
}
|
|
|
|
m_bDemoRec = FALSE;
|
|
m_demoTime = 0;
|
|
}
|
|
|
|
// Début de la reproduction d'une démo.
|
|
// Lit le fichier sur disque.
|
|
|
|
BOOL CEvent::DemoPlayStart()
|
|
{
|
|
char filename[MAX_PATH];
|
|
FILE* file = NULL;
|
|
DemoHeader header;
|
|
int nb, world, time, total;
|
|
|
|
m_pDemoBuffer = (DemoEvent*)malloc(MAXDEMO*sizeof(DemoEvent));
|
|
if ( m_pDemoBuffer == NULL ) return FALSE;
|
|
memset(m_pDemoBuffer, 0, MAXDEMO*sizeof(DemoEvent));
|
|
|
|
sprintf(filename, "data\\demo%.3d.blp", m_demoNumber);
|
|
AddCDPath(filename); // ajoute l'accès au CD-Rom
|
|
file = fopen(filename, "rb");
|
|
if ( file == NULL )
|
|
{
|
|
DemoPlayStop();
|
|
return FALSE;
|
|
}
|
|
|
|
nb = fread(&header, sizeof(DemoHeader), 1, file);
|
|
if ( nb < 1 )
|
|
{
|
|
DemoPlayStop();
|
|
return FALSE;
|
|
}
|
|
m_bSchool = header.bSchool;
|
|
m_bPrivate = header.bPrivate;
|
|
m_pDecor->SetSkill(header.skill);
|
|
|
|
m_demoEnd = fread(m_pDemoBuffer, sizeof(DemoEvent), MAXDEMO, file);
|
|
fclose(file);
|
|
|
|
m_demoTime = 0;
|
|
m_demoIndex = 0;
|
|
m_bDemoPlay = TRUE;
|
|
m_bDemoRec = FALSE;
|
|
|
|
if ( !m_pDecor->Read(header.world, FALSE, world, time, total) )
|
|
{
|
|
DemoPlayStop();
|
|
return FALSE;
|
|
}
|
|
ChangePhase(WM_PHASE_PLAY);
|
|
InitRandom();
|
|
m_pDecor->SetTime(0);
|
|
m_speed = 1;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// Fin de la reproduction d'une démo.
|
|
|
|
void CEvent::DemoPlayStop()
|
|
{
|
|
if ( m_pDemoBuffer != NULL )
|
|
{
|
|
free(m_pDemoBuffer);
|
|
m_pDemoBuffer = NULL;
|
|
}
|
|
m_bDemoPlay = FALSE;
|
|
m_bDemoRec = FALSE;
|
|
m_demoTime = 0;
|
|
|
|
ChangePhase(WM_PHASE_INIT);
|
|
}
|
|
|
|
// Avance l'index d'enregistrement ou de reproduction.
|
|
|
|
void CEvent::DemoStep()
|
|
{
|
|
int time;
|
|
UINT message;
|
|
WPARAM wParam;
|
|
LPARAM lParam;
|
|
POINT pos;
|
|
|
|
if ( m_phase == WM_PHASE_INIT )
|
|
{
|
|
if ( m_demoTime > DEF_TIME_DEMO ) // ~30 secondes écoulées ?
|
|
{
|
|
m_demoNumber = 0;
|
|
DemoPlayStart(); // démarre une démo automatique
|
|
}
|
|
}
|
|
|
|
if ( m_bDemoPlay && // démo en lecture ?
|
|
m_pDemoBuffer != NULL )
|
|
{
|
|
while ( TRUE )
|
|
{
|
|
time = m_pDemoBuffer[m_demoIndex].time;
|
|
if ( time > m_demoTime ) break;
|
|
|
|
message = m_pDemoBuffer[m_demoIndex].message;
|
|
wParam = m_pDemoBuffer[m_demoIndex].wParam;
|
|
lParam = m_pDemoBuffer[m_demoIndex].lParam;
|
|
m_demoIndex ++;
|
|
|
|
if ( message == WM_MOUSEMOVE &&
|
|
m_mouseType == MOUSETYPEWIN )
|
|
{
|
|
pos = ConvLongToPos(lParam);
|
|
ClientToScreen(m_hWnd, &pos);
|
|
SetCursorPos(pos.x, pos.y);
|
|
}
|
|
|
|
TreatEventBase(message, wParam, lParam);
|
|
|
|
if ( m_demoIndex >= m_demoEnd )
|
|
{
|
|
m_demoNumber ++; // démo suivante
|
|
if ( !DemoPlayStart() ) // démarre la démo suivante
|
|
{
|
|
m_demoNumber = 0; // première démo
|
|
DemoPlayStart(); // démarre la démo
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
m_demoTime ++;
|
|
}
|
|
|
|
// Mémorise un événement.
|
|
|
|
void CEvent::DemoRecEvent(UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
if ( m_bDemoRec && m_pDemoBuffer != NULL &&
|
|
(message == WM_KEYDOWN ||
|
|
message == WM_KEYUP ||
|
|
message == WM_LBUTTONDOWN ||
|
|
message == WM_RBUTTONDOWN ||
|
|
message == WM_MOUSEMOVE ||
|
|
message == WM_LBUTTONUP ||
|
|
message == WM_RBUTTONUP ) )
|
|
{
|
|
if ( m_demoIndex > 0 &&
|
|
message == WM_MOUSEMOVE &&
|
|
m_pDemoBuffer[m_demoIndex-1].time == m_demoTime &&
|
|
m_pDemoBuffer[m_demoIndex-1].message == message )
|
|
{
|
|
m_pDemoBuffer[m_demoIndex-1].wParam = wParam;
|
|
m_pDemoBuffer[m_demoIndex-1].lParam = lParam;
|
|
}
|
|
else
|
|
{
|
|
m_pDemoBuffer[m_demoIndex].time = m_demoTime;
|
|
m_pDemoBuffer[m_demoIndex].message = message;
|
|
m_pDemoBuffer[m_demoIndex].wParam = wParam;
|
|
m_pDemoBuffer[m_demoIndex].lParam = lParam;
|
|
|
|
m_demoIndex ++;
|
|
if ( m_demoIndex >= MAXDEMO )
|
|
{
|
|
DemoRecStop();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Retourne la dernière position de la souris.
|
|
|
|
POINT CEvent::GetLastMousePos()
|
|
{
|
|
return m_oldMousePos;
|
|
}
|
|
|
|
// Traitement d'un événement.
|
|
|
|
BOOL CEvent::TreatEvent(UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
if ( m_bDemoPlay ) // démo en lecture ?
|
|
{
|
|
if ( message == WM_KEYDOWN || // l'utilisateur clique ?
|
|
message == WM_KEYUP ||
|
|
// message == WM_LBUTTONDOWN ||
|
|
// message == WM_RBUTTONDOWN ||
|
|
message == WM_LBUTTONUP ||
|
|
message == WM_RBUTTONUP )
|
|
{
|
|
DemoPlayStop();
|
|
return TRUE;
|
|
}
|
|
if ( message == WM_MOUSEMOVE ) // l'utilisateur bouge ?
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return TreatEventBase(message, wParam, lParam);
|
|
}
|
|
|
|
// Traitement d'un événement.
|
|
|
|
BOOL CEvent::TreatEventBase(UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
POINT pos;
|
|
int fwKeys;
|
|
int i, sound;
|
|
char c;
|
|
BOOL bEnable;
|
|
|
|
pos = ConvLongToPos(lParam);
|
|
fwKeys = wParam;
|
|
|
|
DemoRecEvent(message, wParam, lParam);
|
|
|
|
switch( message )
|
|
{
|
|
case WM_KEYDOWN:
|
|
if ( wParam >= 'A' && wParam <= 'Z' )
|
|
{
|
|
if ( m_posCheat == 0 ) // première lettre ?
|
|
{
|
|
m_rankCheat = -1;
|
|
for ( i=0 ; i<9 ; i++ )
|
|
{
|
|
if ( (char)wParam == cheat_code[i][0] )
|
|
{
|
|
m_rankCheat = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if ( m_rankCheat != -1 )
|
|
{
|
|
c = cheat_code[m_rankCheat][m_posCheat];
|
|
if ( m_posCheat != 0 && m_rankCheat == 8 ) c++; // CONSTRUIRE ?
|
|
if ( (char)wParam == c )
|
|
{
|
|
m_posCheat ++;
|
|
if ( cheat_code[m_rankCheat][m_posCheat] == 0 )
|
|
{
|
|
bEnable = TRUE;
|
|
if ( m_phase == WM_PHASE_PLAY )
|
|
{
|
|
if ( m_rankCheat == 0 ) // vision ?
|
|
{
|
|
m_pDecor->EnableFog(FALSE);
|
|
}
|
|
if ( m_rankCheat == 1 || // power ?
|
|
m_rankCheat == 2 ) // lonesome ?
|
|
{
|
|
m_pDecor->BlupiCheat(m_rankCheat);
|
|
}
|
|
}
|
|
|
|
if ( m_rankCheat == 3 ) // allmissions ?
|
|
{
|
|
m_bAllMissions = !m_bAllMissions;
|
|
bEnable = m_bAllMissions;
|
|
m_bChangeCheat = TRUE;
|
|
}
|
|
if ( m_rankCheat == 4 ) // quick ?
|
|
{
|
|
m_bSpeed = !m_bSpeed;
|
|
bEnable = m_bSpeed;
|
|
m_bChangeCheat = TRUE;
|
|
}
|
|
#if !_DEMO
|
|
if ( m_rankCheat == 5 ) // helpme ?
|
|
{
|
|
m_bHelp = !m_bHelp;
|
|
bEnable = m_bHelp;
|
|
m_bChangeCheat = TRUE;
|
|
}
|
|
#endif
|
|
|
|
if ( m_rankCheat == 6 ) // invincible ?
|
|
{
|
|
m_pDecor->SetInvincible(!m_pDecor->GetInvincible());
|
|
bEnable = m_pDecor->GetInvincible();
|
|
m_bChangeCheat = TRUE;
|
|
}
|
|
|
|
if ( m_rankCheat == 7 ) // superblupi ?
|
|
{
|
|
m_pDecor->SetSuper(!m_pDecor->GetSuper());
|
|
bEnable = m_pDecor->GetSuper();
|
|
m_bChangeCheat = TRUE;
|
|
}
|
|
|
|
#if !_DEMO
|
|
if ( m_rankCheat == 8 ) // construire ?
|
|
{
|
|
m_bAccessBuild = !m_bAccessBuild;
|
|
bEnable = m_bAccessBuild;
|
|
m_bChangeCheat = TRUE;
|
|
}
|
|
#endif
|
|
|
|
if ( m_phase != WM_PHASE_PLAY )
|
|
{
|
|
ChangePhase(m_phase);
|
|
}
|
|
|
|
pos.x = LXIMAGE/2;
|
|
pos.y = LYIMAGE/2;
|
|
if ( bEnable )
|
|
{
|
|
m_pSound->PlayImage(SOUND_BUT, pos);
|
|
}
|
|
else
|
|
{
|
|
m_pSound->PlayImage(SOUND_BOING, pos);
|
|
}
|
|
|
|
m_rankCheat = -1;
|
|
m_posCheat = 0;
|
|
}
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
m_rankCheat = -1;
|
|
m_posCheat = 0;
|
|
|
|
if ( m_phase == WM_PHASE_INTRO1 )
|
|
{
|
|
ChangePhase(WM_PHASE_INTRO2);
|
|
return TRUE;
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_INTRO2 )
|
|
{
|
|
ChangePhase(WM_PHASE_INIT);
|
|
return TRUE;
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_BYE )
|
|
{
|
|
PostMessage(m_hWnd, WM_CLOSE, 0, 0);
|
|
}
|
|
|
|
switch( wParam )
|
|
{
|
|
case VK_END:
|
|
DemoRecStop();
|
|
return TRUE;
|
|
case VK_ESCAPE:
|
|
if ( m_bRunMovie )
|
|
{
|
|
StopMovie();
|
|
m_pSound->SetSuspendSkip(1);
|
|
return TRUE;
|
|
}
|
|
if ( m_phase == WM_PHASE_PLAY ||
|
|
m_phase == WM_PHASE_SETUP ||
|
|
m_phase == WM_PHASE_SETUPp ||
|
|
m_phase == WM_PHASE_READ ||
|
|
m_phase == WM_PHASE_WRITE ||
|
|
m_phase == WM_PHASE_WRITEp ||
|
|
m_phase == WM_PHASE_HELP )
|
|
{
|
|
ChangePhase(WM_PHASE_STOP);
|
|
return TRUE;
|
|
}
|
|
if ( m_phase == WM_PHASE_STOP ||
|
|
m_phase == WM_PHASE_LOST ||
|
|
m_phase == WM_PHASE_BUILD )
|
|
{
|
|
ChangePhase(WM_PHASE_INFO);
|
|
return TRUE;
|
|
}
|
|
if ( m_phase == WM_PHASE_INFO )
|
|
{
|
|
ChangePhase(WM_PHASE_INIT);
|
|
return TRUE;
|
|
}
|
|
if ( m_phase == WM_PHASE_BUTTON ||
|
|
m_phase == WM_PHASE_TERM ||
|
|
m_phase == WM_PHASE_MUSIC ||
|
|
m_phase == WM_PHASE_REGION )
|
|
{
|
|
ChangePhase(WM_PHASE_BUILD);
|
|
return TRUE;
|
|
}
|
|
if ( m_phase == WM_PHASE_INIT )
|
|
{
|
|
ChangePhase(WM_PHASE_BYE);
|
|
return TRUE;
|
|
}
|
|
if ( m_phase == WM_PHASE_BYE )
|
|
{
|
|
PostMessage(m_hWnd, WM_CLOSE, 0, 0);
|
|
break;
|
|
}
|
|
return TRUE;
|
|
case VK_RETURN:
|
|
if ( m_phase == WM_PHASE_PLAY ||
|
|
m_phase == WM_PHASE_READ ||
|
|
m_phase == WM_PHASE_WRITE ||
|
|
m_phase == WM_PHASE_SETUP )
|
|
{
|
|
ChangePhase(WM_PHASE_STOP);
|
|
return TRUE;
|
|
}
|
|
if ( m_phase == WM_PHASE_INIT ||
|
|
m_phase == WM_PHASE_LOST ||
|
|
m_phase == WM_PHASE_BUILD )
|
|
{
|
|
ChangePhase(WM_PHASE_INFO);
|
|
return TRUE;
|
|
}
|
|
if ( m_phase == WM_PHASE_INFO ||
|
|
m_phase == WM_PHASE_STOP ||
|
|
m_phase == WM_PHASE_HELP ||
|
|
m_phase == WM_PHASE_SETUPp ||
|
|
m_phase == WM_PHASE_WRITEp )
|
|
{
|
|
ChangePhase(WM_PHASE_PLAY);
|
|
return TRUE;
|
|
}
|
|
if ( m_phase == WM_PHASE_BUTTON ||
|
|
m_phase == WM_PHASE_TERM ||
|
|
m_phase == WM_PHASE_MUSIC ||
|
|
m_phase == WM_PHASE_REGION )
|
|
{
|
|
ChangePhase(WM_PHASE_BUILD);
|
|
return TRUE;
|
|
}
|
|
return TRUE;
|
|
case VK_LEFT:
|
|
//? DecorShift(-4,4);
|
|
DecorShift(-2,2);
|
|
return TRUE;
|
|
case VK_RIGHT:
|
|
//? DecorShift(4,-4);
|
|
DecorShift(2,-2);
|
|
return TRUE;
|
|
case VK_UP:
|
|
//? DecorShift(-6,-6);
|
|
DecorShift(-3,-3);
|
|
return TRUE;
|
|
case VK_DOWN:
|
|
//? DecorShift(6,6);
|
|
DecorShift(3,3);
|
|
return TRUE;
|
|
case VK_HOME:
|
|
pos = m_pDecor->GetHome();
|
|
m_pDecor->SetCoin(pos);
|
|
return TRUE;
|
|
case VK_SPACE:
|
|
if ( m_bRunMovie )
|
|
{
|
|
StopMovie();
|
|
m_pSound->SetSuspendSkip(1);
|
|
return TRUE;
|
|
}
|
|
m_pDecor->FlipOutline();
|
|
return TRUE;
|
|
case VK_PAUSE:
|
|
m_bPause = !m_bPause;
|
|
if ( m_phase == WM_PHASE_PLAY )
|
|
{
|
|
if ( m_bPause )
|
|
{
|
|
m_pSound->SuspendMusic();
|
|
}
|
|
else
|
|
{
|
|
m_pSound->RestartMusic();
|
|
}
|
|
}
|
|
return TRUE;
|
|
case VK_CONTROL:
|
|
m_bCtrlDown = TRUE;
|
|
if ( m_phase == WM_PHASE_BUILD )
|
|
{
|
|
m_bFillMouse = TRUE;
|
|
MouseSprite(GetMousePos());
|
|
}
|
|
else
|
|
{
|
|
m_bFillMouse = FALSE;
|
|
}
|
|
return TRUE;
|
|
case VK_F1:
|
|
if ( m_phase == WM_PHASE_PLAY )
|
|
{
|
|
// Montre ou cache les infos tout en haut.
|
|
if ( m_pDecor->GetInfoMode() ) sound = SOUND_CLOSE;
|
|
else sound = SOUND_OPEN;
|
|
pos.x = LXIMAGE/2;
|
|
pos.y = LYIMAGE/2;
|
|
m_pSound->PlayImage(sound, pos);
|
|
m_pDecor->SetInfoMode(!m_pDecor->GetInfoMode());
|
|
}
|
|
return TRUE;
|
|
case VK_F9:
|
|
if ( m_phase == WM_PHASE_PLAY )
|
|
{
|
|
m_pDecor->MemoPos(0, m_bCtrlDown);
|
|
}
|
|
return TRUE;
|
|
case VK_F10:
|
|
if ( m_phase == WM_PHASE_PLAY )
|
|
{
|
|
m_pDecor->MemoPos(1, m_bCtrlDown);
|
|
}
|
|
return TRUE;
|
|
case VK_F11:
|
|
if ( m_phase == WM_PHASE_PLAY )
|
|
{
|
|
m_pDecor->MemoPos(2, m_bCtrlDown);
|
|
}
|
|
return TRUE;
|
|
case VK_F12:
|
|
if ( m_phase == WM_PHASE_PLAY )
|
|
{
|
|
m_pDecor->MemoPos(3, m_bCtrlDown);
|
|
}
|
|
return TRUE;
|
|
}
|
|
break;
|
|
|
|
case WM_KEYUP:
|
|
switch( wParam )
|
|
{
|
|
case VK_CONTROL:
|
|
m_bCtrlDown = FALSE;
|
|
m_bFillMouse = FALSE;
|
|
MouseSprite(GetMousePos());
|
|
return TRUE;
|
|
}
|
|
break;
|
|
|
|
case WM_LBUTTONDOWN:
|
|
case WM_RBUTTONDOWN:
|
|
m_bMousePress = TRUE;
|
|
MouseSprite(pos);
|
|
//? DecorAutoShift(pos);
|
|
if ( EventButtons(message, wParam, lParam) ) return TRUE;
|
|
if ( m_phase == WM_PHASE_BUILD )
|
|
{
|
|
if ( BuildDown(pos, fwKeys) ) return TRUE;
|
|
}
|
|
if ( m_phase == WM_PHASE_PLAY )
|
|
{
|
|
if ( PlayDown(pos, fwKeys) ) return TRUE;
|
|
}
|
|
break;
|
|
|
|
case WM_MOUSEMOVE:
|
|
if ( m_mouseType == MOUSETYPEGRA )
|
|
{
|
|
if ( m_bShowMouse )
|
|
{
|
|
ShowCursor(FALSE); // cache la souris
|
|
m_pPixmap->MouseShow(TRUE); // montre sprite
|
|
m_bShowMouse = FALSE;
|
|
}
|
|
}
|
|
if ( m_mouseType == MOUSETYPEWINPOS &&
|
|
(pos.x != m_oldMousePos.x ||
|
|
pos.y != m_oldMousePos.y ) )
|
|
{
|
|
m_oldMousePos = pos;
|
|
ClientToScreen(m_hWnd, &m_oldMousePos);
|
|
SetCursorPos(m_oldMousePos.x, m_oldMousePos.y); // (*)
|
|
}
|
|
m_oldMousePos = pos;
|
|
|
|
MouseSprite(pos);
|
|
if ( EventButtons(message, wParam, lParam) ) return TRUE;
|
|
if ( m_phase == WM_PHASE_BUILD )
|
|
{
|
|
if ( BuildMove(pos, fwKeys) ) return TRUE;
|
|
}
|
|
if ( m_phase == WM_PHASE_PLAY )
|
|
{
|
|
if ( PlayMove(pos, fwKeys) ) return TRUE;
|
|
}
|
|
break;
|
|
|
|
case WM_NCMOUSEMOVE:
|
|
if ( m_mouseType == MOUSETYPEGRA )
|
|
{
|
|
if ( !m_bShowMouse )
|
|
{
|
|
ShowCursor(TRUE); // montre la souris
|
|
m_pPixmap->MouseShow(FALSE); // cache sprite
|
|
m_bShowMouse = TRUE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_LBUTTONUP:
|
|
case WM_RBUTTONUP:
|
|
m_bMousePress = FALSE;
|
|
if ( EventButtons(message, wParam, lParam) ) return TRUE;
|
|
if ( m_phase == WM_PHASE_BUILD )
|
|
{
|
|
if ( BuildUp(pos, fwKeys) ) return TRUE;
|
|
}
|
|
if ( m_phase == WM_PHASE_PLAY )
|
|
{
|
|
if ( PlayUp(pos, fwKeys) ) return TRUE;
|
|
}
|
|
if ( m_phase == WM_PHASE_BYE )
|
|
{
|
|
PostMessage(m_hWnd, WM_CLOSE, 0, 0);
|
|
}
|
|
break;
|
|
|
|
case WM_PHASE_DEMO:
|
|
m_demoNumber = 0;
|
|
DemoPlayStart();
|
|
break;
|
|
|
|
case WM_PHASE_SCHOOL:
|
|
m_bSchool = TRUE;
|
|
m_bPrivate = FALSE;
|
|
if ( ChangePhase(WM_PHASE_INFO) ) return TRUE;
|
|
break;
|
|
|
|
case WM_PHASE_MISSION:
|
|
m_bSchool = FALSE;
|
|
m_bPrivate = FALSE;
|
|
if ( m_mission == 0 ) // première mission ?
|
|
{
|
|
if ( ChangePhase(WM_PHASE_H0MOVIE) ) return TRUE;
|
|
}
|
|
else
|
|
{
|
|
if ( ChangePhase(WM_PHASE_INFO) ) return TRUE;
|
|
}
|
|
break;
|
|
|
|
case WM_PHASE_PRIVATE:
|
|
m_bSchool = FALSE;
|
|
m_bPrivate = TRUE;
|
|
if ( ChangePhase(WM_PHASE_INFO) ) return TRUE;
|
|
break;
|
|
|
|
case WM_PHASE_INTRO1:
|
|
case WM_PHASE_INTRO2:
|
|
case WM_PHASE_INIT:
|
|
case WM_PHASE_HISTORY0:
|
|
case WM_PHASE_HISTORY1:
|
|
case WM_PHASE_INFO:
|
|
case WM_PHASE_PLAY:
|
|
case WM_PHASE_READ:
|
|
case WM_PHASE_WRITE:
|
|
case WM_PHASE_WRITEp:
|
|
case WM_PHASE_BUILD:
|
|
case WM_PHASE_BUTTON:
|
|
case WM_PHASE_TERM:
|
|
case WM_PHASE_STOP:
|
|
case WM_PHASE_HELP:
|
|
case WM_PHASE_MUSIC:
|
|
case WM_PHASE_REGION:
|
|
case WM_PHASE_SETUP:
|
|
case WM_PHASE_SETUPp:
|
|
case WM_PHASE_PLAYMOVIE:
|
|
case WM_PHASE_H0MOVIE:
|
|
case WM_PHASE_H1MOVIE:
|
|
case WM_PHASE_H2MOVIE:
|
|
case WM_PHASE_WINMOVIE:
|
|
case WM_PHASE_BYE:
|
|
if ( ChangePhase(message) ) return TRUE;
|
|
break;
|
|
|
|
case WM_PHASE_UNDO:
|
|
m_pDecor->UndoBack(); // revient en arrière
|
|
break;
|
|
|
|
case WM_PREV:
|
|
m_pDecor->SetInvincible(FALSE);
|
|
m_pDecor->SetSuper(FALSE);
|
|
if ( m_bPrivate )
|
|
{
|
|
if ( m_private > 0 )
|
|
{
|
|
m_private --;
|
|
if ( ChangePhase(WM_PHASE_INFO) ) return TRUE;
|
|
}
|
|
}
|
|
else if ( m_bSchool )
|
|
{
|
|
if ( m_exercice > 0 )
|
|
{
|
|
m_exercice --;
|
|
if ( ChangePhase(WM_PHASE_INFO) ) return TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( m_mission > 0 )
|
|
{
|
|
m_mission --;
|
|
if ( ChangePhase(WM_PHASE_INFO) ) return TRUE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_NEXT:
|
|
m_pDecor->SetInvincible(FALSE);
|
|
m_pDecor->SetSuper(FALSE);
|
|
if ( m_bPrivate )
|
|
{
|
|
if ( m_private < 20-1 )
|
|
{
|
|
m_private ++;
|
|
if ( ChangePhase(WM_PHASE_INFO) ) return TRUE;
|
|
}
|
|
}
|
|
else if ( m_bSchool )
|
|
{
|
|
if ( m_exercice < 99 )
|
|
{
|
|
m_exercice ++;
|
|
if ( ChangePhase(WM_PHASE_INFO) ) return TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( m_mission < 99 )
|
|
{
|
|
m_mission ++;
|
|
if ( m_maxMission < m_mission )
|
|
{
|
|
m_maxMission = m_mission;
|
|
}
|
|
if ( ChangePhase(WM_PHASE_INFO) ) return TRUE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_DECOR1:
|
|
SetState(WM_DECOR1, 1);
|
|
SetState(WM_DECOR2, 0);
|
|
SetState(WM_DECOR3, 0);
|
|
SetState(WM_DECOR4, 0);
|
|
SetState(WM_DECOR5, 0);
|
|
break;
|
|
|
|
case WM_DECOR2:
|
|
SetState(WM_DECOR1, 0);
|
|
SetState(WM_DECOR2, 1);
|
|
SetState(WM_DECOR3, 0);
|
|
SetState(WM_DECOR4, 0);
|
|
SetState(WM_DECOR5, 0);
|
|
break;
|
|
|
|
case WM_DECOR3:
|
|
SetState(WM_DECOR1, 0);
|
|
SetState(WM_DECOR2, 0);
|
|
SetState(WM_DECOR3, 1);
|
|
SetState(WM_DECOR4, 0);
|
|
SetState(WM_DECOR5, 0);
|
|
break;
|
|
|
|
case WM_DECOR4:
|
|
SetState(WM_DECOR1, 0);
|
|
SetState(WM_DECOR2, 0);
|
|
SetState(WM_DECOR3, 0);
|
|
SetState(WM_DECOR4, 1);
|
|
SetState(WM_DECOR5, 0);
|
|
break;
|
|
|
|
case WM_DECOR5:
|
|
SetState(WM_DECOR1, 0);
|
|
SetState(WM_DECOR2, 0);
|
|
SetState(WM_DECOR3, 0);
|
|
SetState(WM_DECOR4, 0);
|
|
SetState(WM_DECOR5, 1);
|
|
break;
|
|
|
|
case WM_PHASE_SKILL1:
|
|
m_pDecor->SetSkill(0);
|
|
SetState(WM_PHASE_SKILL1, TRUE);
|
|
SetState(WM_PHASE_SKILL2, FALSE);
|
|
break;
|
|
case WM_PHASE_SKILL2:
|
|
m_pDecor->SetSkill(1);
|
|
SetState(WM_PHASE_SKILL1, FALSE);
|
|
SetState(WM_PHASE_SKILL2, TRUE);
|
|
break;
|
|
|
|
case WM_BUTTON0:
|
|
case WM_BUTTON1:
|
|
case WM_BUTTON2:
|
|
case WM_BUTTON3:
|
|
case WM_BUTTON4:
|
|
case WM_BUTTON5:
|
|
case WM_BUTTON6:
|
|
case WM_BUTTON7:
|
|
case WM_BUTTON8:
|
|
case WM_BUTTON9:
|
|
case WM_BUTTON10:
|
|
case WM_BUTTON11:
|
|
case WM_BUTTON12:
|
|
case WM_BUTTON13:
|
|
case WM_BUTTON14:
|
|
case WM_BUTTON15:
|
|
case WM_BUTTON16:
|
|
case WM_BUTTON17:
|
|
case WM_BUTTON18:
|
|
case WM_BUTTON19:
|
|
case WM_BUTTON20:
|
|
case WM_BUTTON21:
|
|
case WM_BUTTON22:
|
|
case WM_BUTTON23:
|
|
case WM_BUTTON24:
|
|
case WM_BUTTON25:
|
|
case WM_BUTTON26:
|
|
case WM_BUTTON27:
|
|
case WM_BUTTON28:
|
|
case WM_BUTTON29:
|
|
case WM_BUTTON30:
|
|
case WM_BUTTON31:
|
|
case WM_BUTTON32:
|
|
case WM_BUTTON33:
|
|
case WM_BUTTON34:
|
|
case WM_BUTTON35:
|
|
case WM_BUTTON36:
|
|
case WM_BUTTON37:
|
|
case WM_BUTTON38:
|
|
case WM_BUTTON39:
|
|
ChangeButtons(message);
|
|
break;
|
|
|
|
case WM_READ0:
|
|
case WM_READ1:
|
|
case WM_READ2:
|
|
case WM_READ3:
|
|
case WM_READ4:
|
|
case WM_READ5:
|
|
case WM_READ6:
|
|
case WM_READ7:
|
|
case WM_READ8:
|
|
case WM_READ9:
|
|
Read(message);
|
|
ChangePhase(WM_PHASE_PLAY); // joue
|
|
break;
|
|
|
|
case WM_WRITE0:
|
|
case WM_WRITE1:
|
|
case WM_WRITE2:
|
|
case WM_WRITE3:
|
|
case WM_WRITE4:
|
|
case WM_WRITE5:
|
|
case WM_WRITE6:
|
|
case WM_WRITE7:
|
|
case WM_WRITE8:
|
|
case WM_WRITE9:
|
|
Write(message);
|
|
if ( m_phase == WM_PHASE_WRITEp )
|
|
{
|
|
ChangePhase(WM_PHASE_PLAY); // joue
|
|
}
|
|
else
|
|
{
|
|
ChangePhase(WM_PHASE_STOP); // pause
|
|
}
|
|
break;
|
|
|
|
case WM_MOVIE:
|
|
StartMovie("movie\\essai.avi");
|
|
ChangePhase(WM_PHASE_INIT);
|
|
break;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
// (*) Sans cela, il existe un drôle de problème sur
|
|
// certains PC: la souris ne suis pas le mouvement
|
|
// réel effectué.
|
|
// Problème résolu par Denis !
|
|
|
|
|
|
// Affiche un caractère de debug tout en haut.
|
|
|
|
void CEvent::DebugDisplay(char m)
|
|
{
|
|
char text[10];
|
|
POINT pos;
|
|
RECT rect;
|
|
|
|
m_debugPos.x += 8;
|
|
if ( m_debugPos.x > LXIMAGE-8 )
|
|
{
|
|
m_debugPos.x = 0;
|
|
pos.x = 0;
|
|
pos.y = 0;
|
|
rect.left = pos.x;
|
|
rect.right = pos.x+LXIMAGE;
|
|
rect.top = pos.y;
|
|
rect.bottom = pos.y+DIMLITTLEY;
|
|
m_pPixmap->DrawPart(-1, CHBACK, pos, rect, 1); // dessine le fond
|
|
}
|
|
|
|
text[0] = m;
|
|
text[1] = 0;
|
|
|
|
DrawText(m_pPixmap, m_debugPos, text, FONTLITTLE);
|
|
}
|
|
|
|
// Passe les images d'introduction.
|
|
|
|
void CEvent::IntroStep()
|
|
{
|
|
m_introTime ++;
|
|
|
|
if ( m_introTime > 20*3 )
|
|
{
|
|
if ( m_phase == WM_PHASE_INTRO1 )
|
|
{
|
|
ChangePhase(WM_PHASE_INTRO2);
|
|
return;
|
|
}
|
|
|
|
if ( m_phase == WM_PHASE_INTRO2 )
|
|
{
|
|
ChangePhase(WM_PHASE_INIT);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|