00001
#pragma warning(disable: 4786)
00002
00003
#include <fstream>
00004
#include <string>
00005
#include <iostream>
00006
#include <assert.h>
00007
00008
#include "bsp.h"
00009
#include "level.h"
00010
#include "game_manager.h"
00011
#include "main.h"
00012
#include "errrors_display.h"
00013
00014
using namespace std;
00015
00016
00017 #define DELAY_BETWEEN_ADDED_ITEMS 0.5
00018
00019 #define PX_GAME_OVER_MESSAGE TX_SCREEN/2-276/2
00020 #define PY_GAME_OVER_MESSAGE TY_SCREEN/2-128/2
00021
00022 #define PX_VICTORY_MESSAGE TX_SCREEN/2-276/2
00023 #define PY_VICTORY_MESSAGE TY_SCREEN/2-128/2
00024
00025 #define PX_PRESS_SPACE_MESSAGE TX_SCREEN/2-276/2
00026 #define PY_PRESS_SPACE_MESSAGE TY_SCREEN/2-128/2
00027
00028 #define CADEAUX_FREQUENCY 0.8 // delais entre l'addition des cadeaux !
00029
00030 #define PX_COEURS 50
00031 #define PY_COEURS 550
00032 #define ECART_X_COEURS 40
00033
00034 #define X_DISPLAY_LEFT_TIME 200
00035 #define Y_DISPLAY_LEFT_TIME 510
00036
00037 #define X_DISPLAY_SCORE 200
00038 #define Y_DISPLAY_SCORE 550
00039
00040 #define PERCENT_CADEAUX_POINTS 80
00041 #define PERCENT_CADEAUX_TELEPORTEUR 6
00042 #define PERCENT_CADEAUX_HOLOGRAMME 6
00043 #define PERCENT_CADEAUX_BOMB 6
00044 #define PERCENT_CADEAUX_COEUR 2
00045
00046
00047 #define KEYDOWN(buf, key) (buf[key] & 0x80)
00048
00049
00050
00051 static char *
Level_Files[
N_LEVELS] = {
"../levels/level1.txt",
"../levels/level2.txt",
"../levels/level3.txt"};
00052
00053
00054
00055
00056
00057
00058
00059 cGame_Manager::cGame_Manager()
00060 {
00061
bool bDisplay_Square_Areas =
false;
00062
bool bDisplay_Ennemies_Path =
false;
00063
bool bDisplay_Path_Graph =
false;
00064
bool bGame_Paused =
false;
00065
bool bInvincible =
false;
00066
00067
Game_World = NULL;
00068
Level_Loader =
new cLevel_Loader();
00069
Initiate_Unit_Defs();
00070
World_Debug_Displayer =
new cGame_World_Debug_Displayer;
00071
Player =
new cPlayer(20,20);
00072
Nb_Seconds_For_Level = 200;
00073
Game_State =
INITIALIZING;
00074
DXUtil_Timer(
TIMER_RESET );
00075
Time_Of_Last_Bonus =
DXUtil_Timer(
TIMER_GETAPPTIME );
00076
Time_Since_Level_Start = 0.0;
00077
Time_Last_Generated_Cadeau =
DXUtil_Timer(
TIMER_GETAPPTIME );
00078
bTeleporteur_In_Game =
false;
00079
Score = 0;
00080 }
00081
00082
00083
00084 cGame_Manager::~cGame_Manager()
00085 {
00086
delete(
Level_Loader);
00087
delete(
World_Debug_Displayer);
00088
delete(
Player);
00089
00090 std::list<cEnnemy*>::iterator enn_itr;
00091 std::list<cInteractive_Item*>::iterator bonus_itr;
00092
00093
00094
for( enn_itr =
Ennemies_List.begin() ; enn_itr !=
Ennemies_List.end() ; enn_itr++)
00095
delete( (*enn_itr) );
00096
00097
00098
for( bonus_itr =
Bonus_List.begin() ; bonus_itr !=
Bonus_List.end() ; bonus_itr++)
00099
delete( (*bonus_itr) );
00100
00101
SAFE_DELETE(
pDisplay_White_Ball );
00102
SAFE_DELETE(
pDisplay_Red_Ball );
00103
SAFE_DELETE(
pDisplay_Blue_Ball );
00104
SAFE_DELETE(
pDisplay_Green_Ball );
00105
SAFE_DELETE(
pDisplay_Bomb );
00106
SAFE_DELETE(
pDisplay_Teleporteur );
00107
SAFE_DELETE(
pDisplay_Hologramme );
00108
SAFE_DELETE(
pDisplay_Cadeau );
00109
SAFE_DELETE(
pDisplay_Red_Trap );
00110
SAFE_DELETE(
pDisplay_Blue_Trap );
00111
SAFE_DELETE(
pDisplay_Green_Trap );
00112
SAFE_DELETE(
pDisplay_Coeur );
00113
00114
SAFE_DELETE(
pDisplay_Game_Over);
00115
SAFE_DELETE(
pDisplay_Victory );
00116
SAFE_DELETE(
pDisplay_Press_Space) ;
00117
00118
00119 }
00120
00121
00122 void cGame_Manager::Clear()
00123 {
00124
00125
SAFE_DELETE(
Game_World );
00126
00127 std::list<cEnnemy*>::iterator enn_itr;
00128 std::list<cInteractive_Item*>::iterator bonus_itr;
00129
00130
00131
for( enn_itr =
Ennemies_List.begin() ; enn_itr !=
Ennemies_List.end() ; enn_itr++)
00132
delete( (*enn_itr) );
00133
00134
00135
for( bonus_itr =
Bonus_List.begin() ; bonus_itr !=
Bonus_List.end() ; bonus_itr++)
00136
delete( (*bonus_itr) );
00137
00138
Ennemies_List.clear();
00139
Bonus_List.clear();
00140
bTeleporteur_In_Game =
false;
00141
00142 }
00143
00144
00145 void cGame_Manager::Reset()
00146 {
00147
DXUtil_Timer(
TIMER_RESET );
00148
00149
Time_Of_Last_Bonus =
DXUtil_Timer(
TIMER_GETAPPTIME );
00150
Time_Since_Level_Start = 0.0;
00151
Time_Last_Generated_Cadeau =
DXUtil_Timer(
TIMER_GETAPPTIME );
00152
00153 std::list<cInteractive_Item*>::iterator bonus_itr;
00154
for( bonus_itr =
Bonus_List.begin() ; bonus_itr !=
Bonus_List.end() ; bonus_itr++)
00155 {
00156 (*bonus_itr)->Reset();
00157 }
00158 }
00159
00160
00161
00162
00163
00164
00165 bool cGame_Manager::Load_Level(
int i)
00166 {
00167
Clear();
00168
bool valid;
00169
Game_World =
new cGame_World();
00170 valid =
Level_Loader->
Load(
Level_Files[i] ,
this );
00171
if( ! valid)
00172
return false;
00173
00174
Game_World->
Decorate();
00175
Reset();
00176
00177
00178
Game_State =
READY_TO_START;
00179
return true;
00180 }
00181
00182
00183
00184
00185
00186 void cGame_Manager::Start()
00187 {
00188 std::string err_message;
00189
00190
Game_State =
RUNNING;
00191
DXUtil_Timer(
TIMER_RESET );
00192
Time_Of_Last_Bonus =
DXUtil_Timer(
TIMER_GETAPPTIME );
00193
00194 std::list<cEnnemy*>::iterator enn_itr;
00195
for( enn_itr =
Ennemies_List.begin() ; enn_itr !=
Ennemies_List.end() ; enn_itr++)
00196 (*enn_itr)->Time_Stamp_Last_Move =
DXUtil_Timer(
TIMER_GETAPPTIME )-
FREQUENCY_MOVE;
00197
00198
Player->
Time_Stamp_Last_Move =
DXUtil_Timer(
TIMER_GETAPPTIME )-
FREQUENCY_MOVE;
00199
00200 }
00201
00202
00203 void cGame_Manager::Try_Start()
00204 {
00205
if(
Game_State ==
READY_TO_START )
00206
Start() ;
00207 }
00208
00209
00210 bool cGame_Manager::Add_Bonus( Interactive_Item_Type bonus ,
int x,
int y)
00211 {
00212
switch(bonus)
00213 {
00214
case BOMB:
00215
if(
Player->
Nb_Bombs ==0 )
00216
return false;
00217
Bonus_List.push_front(
new cBomb(x,y) );
00218
Player->
Nb_Bombs--;
00219
return true;
00220
case TELEPORTEUR:
00221
if(
Player->
Nb_Teleporteurs ==0 )
00222
return false;
00223
Bonus_List.push_front(
new cTeleporteur(x,y) );
00224
Player->
Nb_Teleporteurs--;
00225
return true;
00226
case HOLOGRAMME:
00227
if(
Player->
Nb_Hologrammes ==0 )
00228
return false;
00229
Bonus_List.push_front(
new cHologramme(x,y) );
00230
Player->
Nb_Hologrammes --;
00231
return true;
00232
case RED_TRAP:
00233
Bonus_List.push_front(
new cRed_Trap(x,y) );
00234
return true;
00235
case BLUE_TRAP:
00236
Bonus_List.push_front(
new cBlue_Trap(x,y) );
00237
return true;
00238
case GREEN_TRAP:
00239
Bonus_List.push_front(
new cGreen_Trap(x,y) );
00240
return true;
00241
default:
00242
return false;
00243 }
00244 }
00245
00246
00247 bool cGame_Manager::Add_Ennemy( Ennemy_Type bonus ,
int x,
int y)
00248 {
00249
switch(bonus)
00250 {
00251
case RED_BALL:
00252
Ennemies_List.push_front(
new cRed_Ball(x,y) );
00253
return true;
00254
case BLUE_BALL:
00255
Ennemies_List.push_front(
new cBlue_Ball(x,y) );
00256
return true;
00257
case GREEN_BALL:
00258
Ennemies_List.push_front(
new cGreen_Ball(x,y) );
00259
return true;
00260
default:
00261
return false;
00262 }
00263 }
00264
00265
00266
00267
00268 void Call_Back_Display_Wall(
cHV_Node * node)
00269 {
00270 node->
Divider.Display(
g_pDisplay);
00271 }
00272
00273
00274
00275 void cGame_Manager::Display_Score()
00276 {
00277
char c_str[20];
00278 std::string str_score;
00279 DDSURFACEDESC2 ddsd;
00280 HRESULT hr;
00281
00282
00283 _itoa(
Score,c_str,10);
00284 str_score.erase();
00285 str_score.append( c_str );
00286
00287 str_score.copy(c_str,20,
'\0');
00288 c_str[str_score.size()]=
'\0';
00289
00290
00291 ddsd.dwSize =
sizeof(ddsd);
00292 hr =
g_pScore_Text->
GetDDrawSurface()->Lock( NULL, &ddsd, DDLOCK_WAIT, NULL );
00293
if( hr != DD_OK)
00294 {
00295 Display_Fatal_Error(
hWnd ,
"cGame_Manager::Display_Score()",hr);
00296
_DbgOut(
"game_manager.cpp",119,hr,
"void cGame_Manager::Display_Score()" );
00297 PostQuitMessage(0);
00298
return;
00299 }
00300
else
00301 {
00302
for(
int i=0;i<ddsd.dwHeight;i++)
00303 memset( (
unsigned char*)ddsd.lpSurface+i*ddsd.lPitch , 0 , ddsd.dwWidth );
00304
g_pScore_Text->
GetDDrawSurface()->Unlock(NULL);
00305 }
00306
00307
00308
g_pScore_Text->
DrawText(NULL,c_str,0,0, RGB(0,0,0),RGB(0,255,0) );
00309
g_pDisplay->
Blt(
X_DISPLAY_SCORE ,
Y_DISPLAY_SCORE ,
g_pScore_Text->
GetDDrawSurface() , NULL);
00310 }
00311
00312
00313
00314 void cGame_Manager::Display_Time()
00315 {
00316 std::string str_time;
00317 str_time = 10;
00318
char c_str[20];
00319
int n_mins;
00320
int n_secs;
00321 DDSURFACEDESC2 ddsd;
00322 HRESULT hr;
00323
00324
00325 n_secs =
Nb_Seconds_For_Level - (
int)
Time_Since_Level_Start;
00326
if( n_secs < 0) n_secs =0;
00327
00328 n_mins = n_secs/60;
00329 n_secs -= n_mins*60;
00330
00331 _itoa(n_mins,c_str,10);
00332
00333 str_time.erase();
00334 str_time.append( c_str );
00335 c_str[0]=
':';
00336 c_str[1]=
'\0';
00337 str_time.append( c_str);
00338
00339
if( n_secs < 10)
00340 {
00341 c_str[0]=
'0';
00342 c_str[1]=
'\0';
00343 str_time.append( c_str);
00344 }
00345
00346 _itoa(n_secs,c_str,10);
00347 str_time.append( c_str);
00348
00349
00350 c_str[0]=
'\0';
00351 str_time.append( c_str);
00352 str_time.copy(c_str,20,
'\0');
00353 c_str[str_time.size()]=
'\0';
00354
00355
00356 ddsd.dwSize =
sizeof(ddsd);
00357 hr =
g_pLeft_Time_Text->
GetDDrawSurface()->Lock( NULL, &ddsd, DDLOCK_WAIT, NULL );
00358
if( hr != DD_OK)
00359 {
00360 Display_Fatal_Error(
hWnd ,
"cGame_Manager::Display()",hr);
00361
_DbgOut(
"game_manager.cpp",119,hr,
"void cGame_Manager::Display()" );
00362 PostQuitMessage(0);
00363
return;
00364 }
00365
else
00366 {
00367
for(
int i=0;i<ddsd.dwHeight;i++)
00368 memset( (
unsigned char*)ddsd.lpSurface+i*ddsd.lPitch , 0 , ddsd.dwWidth );
00369
g_pLeft_Time_Text->
GetDDrawSurface()->Unlock(NULL);
00370 }
00371
00372
00373
g_pLeft_Time_Text->
DrawText(NULL,c_str,0,0, RGB(0,0,0),RGB(0,255,0) );
00374
g_pDisplay->
Blt(
X_DISPLAY_LEFT_TIME ,
Y_DISPLAY_LEFT_TIME ,
g_pLeft_Time_Text->
GetDDrawSurface() , NULL);
00375 }
00376
00377
00378
00379 void cGame_Manager::Display_Debug_X()
00380 {
00381 std::list<cEnnemy*>::iterator enn_itr;
00382
00383
if(
bDisplay_Square_Areas)
00384
World_Debug_Displayer->
Display_Areas( *
g_pDisplay , *
Game_World );
00385
00386
if(
bDisplay_Path_Graph)
00387
World_Debug_Displayer->
Display_Graph( *
g_pDisplay , *
Game_World );
00388
00389
if(
bDisplay_Ennemies_Path )
00390
for( enn_itr =
Ennemies_List.begin() ; enn_itr !=
Ennemies_List.end() ; enn_itr++)
00391 (*enn_itr)->Display_Path();
00392 }
00393
00394
00395 void cGame_Manager::Display_Inventaire_Player()
00396 {
00397
int i;
00398
00399
for( i=0; i <
Player->
Nb_Bombs;i++)
00400
pDisplay_Bomb->
Display(
X_DISPLAY_BOMBS + i*
TX_BOMB ,
Y_DISPLAY_BOMBS );
00401
00402
for( i=0; i <
Player->
Nb_Teleporteurs;i++)
00403
pDisplay_Teleporteur->
Display(
X_DISPLAY_TELEPORTEURS + i*
TX_TELEPORTEUR ,
Y_DISPLAY_TELEPORTEURS );
00404
00405
for( i=0; i <
Player->
Nb_Hologrammes;i++)
00406
pDisplay_Hologramme->
Display(
X_DISPLAY_HOLOGRAMMES + i*
TX_HOLOGRAMME ,
Y_DISPLAY_HOLOGRAMMES );
00407
00408
for( i=0; i <
Player->
Nb_Lives;i++)
00409
pDisplay_Coeur->
Display(
PX_COEURS+i*
ECART_X_COEURS ,
PY_COEURS);
00410
00411
00412 }
00413
00414 void cGame_Manager::Display()
00415 {
00416
00417 std::list<cEnnemy*>::iterator enn_itr;
00418 std::list<cInteractive_Item*>::iterator bonus_itr;
00419
00420
g_pDisplay->
Clear(0);
00421
g_pDisplay->
Blt( 0 , 0 ,
g_pFond->
GetDDrawSurface() , NULL);
00422
00423
Display_Time();
00424
Display_Score();
00425
Display_Debug_X();
00426
Display_Inventaire_Player();
00427
00428
Game_World->
My_BSP.
Apply_To_Each_Node(
Call_Back_Display_Wall);
00429
00430
if(
Player != NULL)
00431
Player->
Display();
00432
00433
for( enn_itr =
Ennemies_List.begin() ; enn_itr !=
Ennemies_List.end() ; enn_itr++)
00434 (*enn_itr)->Display();
00435
00436
for( bonus_itr =
Bonus_List.begin() ; bonus_itr !=
Bonus_List.end() ; bonus_itr++)
00437 (*bonus_itr)->Display();
00438 }
00439
00440
00441
00442
00443 HRESULT
cGame_Manager::Read_Keyboard_And_React()
00444 {
00445 HRESULT hr;
00446 BYTE diks[256];
00447
00448
if( NULL ==
g_pKeyboard )
00449
return S_OK;
00450
00451
00452 ZeroMemory( diks,
sizeof(diks) );
00453 hr =
g_pKeyboard->GetDeviceState(
sizeof(diks), diks );
00454
if( FAILED(hr) )
00455 {
00456
00457
00458
00459
00460
00461
00462 hr =
g_pKeyboard->Acquire();
00463
while( hr == DIERR_INPUTLOST )
00464 hr =
g_pKeyboard->Acquire();
00465
00466
00467
00468
00469
return S_OK;
00470 }
00471
00472 assert(
Player != NULL);
00473
00474
00475
00476
int move_x=0;
00477
int move_y=0;
00478
00479
00480
if(
KEYDOWN(diks , DIK_RIGHT) )
00481 move_x +=
Player->
Get_Speed();
00482
if(
KEYDOWN(diks , DIK_LEFT) )
00483 move_x -=
Player->
Get_Speed();
00484
if(
KEYDOWN(diks , DIK_DOWN) )
00485 move_y +=
Player->
Get_Speed();
00486
if(
KEYDOWN(diks , DIK_UP) )
00487 move_y-=
Player->
Get_Speed();
00488
00489
if( move_x || move_y)
00490
Player->
Move(move_x,move_y);
00491
00492
00493
00494
if(
KEYDOWN(diks , DIK_B) )
00495 {
00496
if(
DXUtil_Timer(
TIMER_GETAPPTIME ) -
Time_Of_Last_Bonus >
DELAY_BETWEEN_ADDED_ITEMS)
00497 {
00498
Add_Bonus(
BOMB ,
Player->
Px ,
Player->
Py );
00499
Time_Of_Last_Bonus =
DXUtil_Timer(
TIMER_GETAPPTIME );
00500 }
00501 }
00502
00503
if(
KEYDOWN(diks , DIK_T) )
00504 {
00505
if(
DXUtil_Timer(
TIMER_GETAPPTIME ) -
Time_Of_Last_Bonus >
DELAY_BETWEEN_ADDED_ITEMS)
00506 {
00507
if(
bTeleporteur_In_Game)
00508 {
00509
Player->
Use_Teleporteur();
00510
Time_Of_Last_Bonus =
DXUtil_Timer(
TIMER_GETAPPTIME );
00511 }
00512
else
00513 {
00514
if(
Add_Bonus(
TELEPORTEUR ,
Player->
Px ,
Player->
Py ))
00515 {
00516
Time_Of_Last_Bonus =
DXUtil_Timer(
TIMER_GETAPPTIME );
00517
bTeleporteur_In_Game =
true;
00518 }
00519 }
00520 }
00521 }
00522
00523
if(
KEYDOWN(diks , DIK_H) )
00524 {
00525
if(
DXUtil_Timer(
TIMER_GETAPPTIME ) -
Time_Of_Last_Bonus >
DELAY_BETWEEN_ADDED_ITEMS)
00526 {
00527
if(
Add_Bonus(
HOLOGRAMME ,
Player->
Px ,
Player->
Py ))
00528
Time_Of_Last_Bonus =
DXUtil_Timer(
TIMER_GETAPPTIME );
00529 }
00530 }
00531
00532
00533
return S_OK;
00534 }
00535
00536
00537
00538 void cGame_Manager::Try_Kill_Player()
00539 {
00540 std::list<cEnnemy*>::iterator enn_itr;
00541
00542
Player->
Nb_Lives--;
00543
if(
Player->
Nb_Lives <= 0)
00544
Game_State =
GAME_OVER;
00545
else
00546 {
00547
Game_State =
READY_TO_START;
00548
for( enn_itr =
Ennemies_List.begin() ; enn_itr !=
Ennemies_List.end() ; enn_itr++)
00549 {
00550 (*enn_itr)->Reset();
00551 }
00552
Nb_Seconds_For_Level -=
Time_Since_Level_Start;
00553
Reset();
00554 }
00555 }
00556
00557
00558
00559 void cGame_Manager::Update_Ennemies()
00560 {
00561
cPoint2D destination;
00562 std::list<cEnnemy*>::iterator enn_itr;
00563
00564
for( enn_itr =
Ennemies_List.begin() ; enn_itr !=
Ennemies_List.end() ; enn_itr++)
00565 (*enn_itr)->Update_Path();
00566
00567
for( enn_itr =
Ennemies_List.begin() ; enn_itr !=
Ennemies_List.end() ; enn_itr++)
00568 (*enn_itr)->Follow_Path();
00569 }
00570
00571
00572
00573 void cGame_Manager::Test_Collisions()
00574 {
00575
int rayon;
00576
unsigned int dist;
00577
00578 std::list<cEnnemy*>::iterator enn_itr;
00579 std::list<cInteractive_Item*>::iterator bonus_itr;
00580
00581
00582
00583
if( !
bInvincible)
00584 {
00585
for( enn_itr =
Ennemies_List.begin() ; enn_itr !=
Ennemies_List.end() ; enn_itr++)
00586 {
00587 dist =
Get_Square_Distance(
cPoint2D((*enn_itr)->Px, (*enn_itr)->Py) ,
00588
cPoint2D(
Player->
Px,
Player->
Py) );
00589 rayon = (*enn_itr)->Get_Rayon() +
Player->
Get_Rayon();
00590
if( dist < rayon*rayon )
00591 {
00592
Try_Kill_Player();
00593
return;
00594 }
00595 }
00596 }
00597
00598
00599
00600
for( bonus_itr =
Bonus_List.begin() ; bonus_itr !=
Bonus_List.end() ; bonus_itr++)
00601 {
00602
00603 dist =
Get_Square_Distance(
cPoint2D((*bonus_itr)->Px, (*bonus_itr)->Py) ,
00604
cPoint2D(
Player->
Px,
Player->
Py) );
00605
00606 rayon = (*bonus_itr)->Get_Rayon() +
Player->
Get_Rayon();
00607
if( dist < rayon*rayon )
00608 {
00609
Player->
React_To_Bonus( (*bonus_itr) );
00610 }
00611 }
00612
00613
00614
00615
for( bonus_itr =
Bonus_List.begin() ; bonus_itr !=
Bonus_List.end() ; bonus_itr++)
00616 {
00617
for( enn_itr =
Ennemies_List.begin() ; enn_itr !=
Ennemies_List.end() ; enn_itr++)
00618 {
00619 dist =
Get_Square_Distance(
cPoint2D((*bonus_itr)->Px, (*bonus_itr)->Py) ,
00620
cPoint2D((*enn_itr)->Px, (*enn_itr)->Py) );
00621
00622 rayon = (*bonus_itr)->Get_Rayon() + (*bonus_itr)->Get_Rayon();
00623
if( dist < rayon*rayon )
00624 {
00625 (*enn_itr)->React_To_Bonus( (*bonus_itr) );
00626 }
00627 }
00628 }
00629
00630
Erase_Ennemies_Garbage_Collector();
00631
Erase_Bonus_Garbage_Collector();
00632 }
00633
00634
00635 void cGame_Manager::Update_Game()
00636 {
00637
Time_Since_Level_Start =
DXUtil_Timer(
TIMER_GETAPPTIME );
00638
00639
if(
Time_Since_Level_Start >=
Nb_Seconds_For_Level )
00640 {
00641
Game_State =
GAME_OVER;
00642 OutputDebugString(
"GAME_OVER !!! \n" );
00643
return;
00644 }
00645
00646
Update_Ennemies();
00647
Test_Collisions();
00648
Generate_Cadeaux();
00649
00650
if(
Ennemies_List.empty() )
00651 {
00652
Game_Manager.
Game_State =
LEVEL_FINISHED;
00653
return;
00654 }
00655 }
00656
00657
00658
00659 void cGame_Manager::Kill_Ennemy(
cEnnemy * ennemy )
00660 {
00661 assert( ennemy != NULL);
00662
Ennemies_Garbage_Collector.push_back( ennemy );
00663 }
00664
00665
00666 void cGame_Manager::Remove_Bonus(
cInteractive_Item * bonus )
00667 {
00668 assert( bonus != NULL);
00669
Bonus_Garbage_Collector.push_back( bonus );
00670 }
00671
00672
00673
00674 void cGame_Manager::Erase_Ennemies_Garbage_Collector( )
00675 {
00676 std::vector<cEnnemy*>::iterator enn_itr;
00677
00678
for( enn_itr =
Ennemies_Garbage_Collector.begin();enn_itr !=
Ennemies_Garbage_Collector.end();enn_itr++)
00679 {
00680
Ennemies_List.remove((*enn_itr));
00681
delete( (*enn_itr));
00682 }
00683
00684
Ennemies_Garbage_Collector.clear();
00685 }
00686
00687
00688 void cGame_Manager::Erase_Bonus_Garbage_Collector( )
00689 {
00690 std::vector<cInteractive_Item*>::iterator bonus_itr;
00691
00692
00693
for( bonus_itr =
Bonus_Garbage_Collector.begin();bonus_itr !=
Bonus_Garbage_Collector.end();bonus_itr++)
00694 {
00695
Bonus_List.remove((*bonus_itr));
00696
delete( (*bonus_itr));
00697 }
00698
00699
Bonus_Garbage_Collector.clear();
00700
00701 }
00702
00703
00704 void cGame_Manager::Main_Loop()
00705 {
00706
00707
00708
switch(
Game_Manager.
Game_State )
00709 {
00710
case RUNNING:
00711
if( !
bGame_Paused)
00712 {
00713
Game_Manager.
Read_Keyboard_And_React();
00714
Game_Manager.
Update_Game();
00715 }
00716
Game_Manager.
Display();
00717
g_pDisplay->
Present();
00718
break;
00719
case INITIALIZING:
00720
Game_Manager.
Load_Level(0 );
00721
break;
00722
case READY_TO_START:
00723
Game_Manager.
Display();
00724
pDisplay_Press_Space->
Display(
PX_PRESS_SPACE_MESSAGE,
PY_PRESS_SPACE_MESSAGE);
00725
g_pDisplay->
Present();
00726
break;
00727
case VICTORY:
00728
Game_Manager.
Display();
00729
pDisplay_Victory->
Display(
PX_VICTORY_MESSAGE,
PY_VICTORY_MESSAGE);
00730
g_pDisplay->
Present();
00731
break;
00732
case LEVEL_FINISHED:
00733
Game_Manager.
Id_Level++;
00734
if(
Game_Manager.
Id_Level ==
N_LEVELS)
00735
Game_Manager.
Game_State =
VICTORY;
00736
else
00737 {
00738
if( !
Game_Manager.
Load_Level(
Game_Manager.
Id_Level) )
00739 {
00740 Display_Fatal_Error(
hWnd,
"erreur à la lecture du niveau");
00741 PostQuitMessage(0);
00742 }
00743 }
00744
break;
00745
case GAME_OVER :
00746
Game_Manager.
Display();
00747
pDisplay_Game_Over->
Display(
PX_GAME_OVER_MESSAGE,
PY_GAME_OVER_MESSAGE);
00748
g_pDisplay->
Present();
00749
break;
00750
default:
00751 Display_Fatal_Error(
hWnd,
"cGame_Manager::Main_Loop() : unknown state \n");
00752 PostQuitMessage(0);
00753
break;
00754 }
00755
00756 }
00757
00758
00759 bool cGame_Manager::Is_Free_Place(
int x,
int y ,
int r )
00760 {
00761
cPoint2D pos(x,y);
00762
unsigned int dist;
00763
unsigned int r_2;
00764
00765
00766
if(
Game_World->
Do_Ball_Intersect_Walls(x , y , r ) )
00767 {
00768
return false;
00769 }
00770
00771
00772 std::list<cEnnemy*>::iterator enn_itr;
00773
for( enn_itr =
Ennemies_List.begin() ; enn_itr !=
Ennemies_List.end() ; enn_itr++)
00774 {
00775 dist =
Get_Square_Distance( pos ,
cPoint2D((*enn_itr)->Px,(*enn_itr)->Py));
00776 r_2 = (r + (*enn_itr)->Get_Rayon())*(r + (*enn_itr)->Get_Rayon());
00777
00778
if( dist* dist < r_2*r_2)
00779
return false;
00780 }
00781
00782
00783 std::list<cInteractive_Item*>::iterator bonus_itr;
00784
for( bonus_itr =
Bonus_List.begin() ; bonus_itr !=
Bonus_List.end() ; bonus_itr++)
00785 {
00786 dist =
Get_Square_Distance( pos ,
cPoint2D((*bonus_itr)->Px,(*bonus_itr)->Py));
00787 r_2 = ( r + (*bonus_itr)->Get_Rayon())*( r + (*bonus_itr)->Get_Rayon());
00788
00789
if( dist*dist < r_2*r_2 )
00790
return false;
00791 }
00792
00793
00794 dist =
Get_Square_Distance( pos ,
cPoint2D(
Player->
Px,
Player->
Py));
00795 r_2 = ( r +
Player->
Get_Rayon())*( r +
Player->
Get_Rayon());
00796
if( dist*dist < r_2 *r_2)
00797
return false;
00798
00799
00800
return true;
00801 }
00802
00803
00804
00805
00806 void cGame_Manager::Generate_Cadeaux()
00807 {
00808
00809 assert(
PERCENT_CADEAUX_POINTS +
PERCENT_CADEAUX_TELEPORTEUR +
00810
PERCENT_CADEAUX_HOLOGRAMME +
PERCENT_CADEAUX_BOMB +
PERCENT_CADEAUX_COEUR ==100);
00811
00812
int x, y;
00813
int ind_cado;
00814
cInteractive_Item * cado=NULL;
00815
00816
00817
if(
DXUtil_Timer(
TIMER_GETAPPTIME ) -
Time_Last_Generated_Cadeau >
CADEAUX_FREQUENCY )
00818 {
00819
00820
do
00821 {
00822 x =
Rnd_Gen.
Get_Int(
RAYON_CADEAU +1, cGame_World::Ecran.p1.X -
RAYON_CADEAU-1);
00823 y =
Rnd_Gen.
Get_Int(
RAYON_CADEAU +1, cGame_World::Ecran.p1.Y -
RAYON_CADEAU-1);
00824 }
while( !
Is_Free_Place( x, y ,
RAYON_CADEAU ) );
00825
00826
00827 ind_cado =
Rnd_Gen.
Get_Int(0,99);
00828
if( ind_cado <
PERCENT_CADEAUX_POINTS)
00829 {
00830 cado =
new cCadeau(x,y,
CADEAU_POINTS);
00831
Bonus_List.push_front(cado);
00832 }
00833
else if( ind_cado <
PERCENT_CADEAUX_POINTS+
PERCENT_CADEAUX_TELEPORTEUR)
00834 {
00835 cado =
new cCadeau(x,y,
CADEAU_TELEPORTEUR);
00836
Bonus_List.push_front(cado);
00837 }
00838
else if( ind_cado <
PERCENT_CADEAUX_POINTS+
PERCENT_CADEAUX_TELEPORTEUR+
PERCENT_CADEAUX_HOLOGRAMME)
00839 {
00840 cado =
new cCadeau(x,y,
CADEAU_HOLOGRAMME);
00841
Bonus_List.push_front(cado);
00842 }
00843
else if( ind_cado <
PERCENT_CADEAUX_POINTS+
PERCENT_CADEAUX_TELEPORTEUR+
PERCENT_CADEAUX_HOLOGRAMME+
PERCENT_CADEAUX_BOMB)
00844 {
00845 cado =
new cCadeau(x,y,
CADEAU_BOMB);
00846
Bonus_List.push_front(cado);
00847 }
00848
else if( ind_cado <
PERCENT_CADEAUX_POINTS+
PERCENT_CADEAUX_TELEPORTEUR+
PERCENT_CADEAUX_HOLOGRAMME+
PERCENT_CADEAUX_BOMB+
PERCENT_CADEAUX_COEUR)
00849 {
00850 cado =
new cCadeau(x,y,
CADEAU_COEUR);
00851
Bonus_List.push_front(cado);
00852 }
00853
else
00854 {
00855
Fatal_Error <<
"nb aleatoire out of range : " << ind_cado <<
"\n";
00856 PostQuitMessage(0);
00857 }
00858
00859
Time_Last_Generated_Cadeau =
DXUtil_Timer(
TIMER_GETAPPTIME );
00860 }
00861 }
00862
00863
00864
00865 void cGame_Manager::Initiate_Unit_Defs()
00866 {
00867
00868 RECT rc_bitmap;
00869 rc_bitmap.bottom = 21;
00870 rc_bitmap.left = 1;
00871 rc_bitmap.right = 21;
00872 rc_bitmap.top = 1;
00873
pDisplay_White_Ball =
new cSprite_Display_Def( rc_bitmap);
00874
00875 rc_bitmap.bottom = 21;
00876 rc_bitmap.left = 22;
00877 rc_bitmap.right = 42;
00878 rc_bitmap.top = 1;
00879
pDisplay_Red_Ball =
new cSprite_Display_Def( rc_bitmap);
00880
00881 rc_bitmap.bottom = 21;
00882 rc_bitmap.left = 43;
00883 rc_bitmap.right = 63;
00884 rc_bitmap.top = 1;
00885
pDisplay_Blue_Ball =
new cSprite_Display_Def( rc_bitmap);
00886
00887 rc_bitmap.bottom = 21;
00888 rc_bitmap.left = 64;
00889 rc_bitmap.right = 84;
00890 rc_bitmap.top = 1;
00891
pDisplay_Green_Ball =
new cSprite_Display_Def( rc_bitmap);
00892
00893 rc_bitmap.bottom = 63;
00894 rc_bitmap.left = 43;
00895 rc_bitmap.right = 63;
00896 rc_bitmap.top = 43;
00897
pDisplay_Bomb =
new cSprite_Display_Def( rc_bitmap);
00898
00899 rc_bitmap.bottom = 63;
00900 rc_bitmap.left = 1;
00901 rc_bitmap.right = 21;
00902 rc_bitmap.top = 43;
00903
pDisplay_Teleporteur =
new cSprite_Display_Def( rc_bitmap);
00904
00905 rc_bitmap.bottom = 63;
00906 rc_bitmap.left = 22;
00907 rc_bitmap.right = 42;
00908 rc_bitmap.top = 43;
00909
pDisplay_Hologramme =
new cSprite_Display_Def( rc_bitmap);
00910
00911 rc_bitmap.bottom = 63;
00912 rc_bitmap.left = 64;
00913 rc_bitmap.right = 84;
00914 rc_bitmap.top = 43;
00915
pDisplay_Cadeau =
new cSprite_Display_Def( rc_bitmap);
00916
00917 rc_bitmap.bottom = 42;
00918 rc_bitmap.left = 22;
00919 rc_bitmap.right = 42;
00920 rc_bitmap.top = 22;
00921
pDisplay_Red_Trap =
new cSprite_Display_Def( rc_bitmap);
00922
00923 rc_bitmap.bottom = 42;
00924 rc_bitmap.left = 43;
00925 rc_bitmap.right = 63;
00926 rc_bitmap.top = 22;
00927
pDisplay_Blue_Trap =
new cSprite_Display_Def( rc_bitmap);
00928
00929 rc_bitmap.bottom = 42;
00930 rc_bitmap.left = 64;
00931 rc_bitmap.right = 84;
00932 rc_bitmap.top = 22;
00933
pDisplay_Green_Trap =
new cSprite_Display_Def( rc_bitmap);
00934
00935 rc_bitmap.bottom = 42;
00936 rc_bitmap.left = 1;
00937 rc_bitmap.right = 21;
00938 rc_bitmap.top = 22;
00939
pDisplay_Coeur =
new cSprite_Display_Def( rc_bitmap);
00940
00941
00942
00943
00944 rc_bitmap.bottom = 64;
00945 rc_bitmap.left = 0;
00946 rc_bitmap.right = 276;
00947 rc_bitmap.top = 0;
00948
pDisplay_Game_Over =
new cBitmap_Display_Def( rc_bitmap);
00949
00950 rc_bitmap.bottom = 127;
00951 rc_bitmap.left = 0;
00952 rc_bitmap.right = 276;
00953 rc_bitmap.top = 63;
00954
pDisplay_Victory =
new cBitmap_Display_Def( rc_bitmap);
00955
00956 rc_bitmap.bottom = 190;
00957 rc_bitmap.left = 0;
00958 rc_bitmap.right = 276;
00959 rc_bitmap.top = 126;
00960
pDisplay_Press_Space =
new cBitmap_Display_Def( rc_bitmap);
00961
00962 }
00963