generated from kdx/gint-project-template
6888 lines
247 KiB
C++
6888 lines
247 KiB
C++
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <math.h>
|
|
#include <stdint.h>
|
|
|
|
#include <gint/rtc.h>
|
|
#include <gint/display.h>
|
|
#include <gint/keyboard.h>
|
|
#include <gint/gint.h>
|
|
#include <gint/bfile.h>
|
|
#include <gint/std/stdlib.h>
|
|
|
|
#include "structs.h"
|
|
#include "primitives.h"
|
|
|
|
#define DEBUG 0
|
|
|
|
#define R_ROUGE 0
|
|
#define R_VERT 1
|
|
#define R_BLEU 2
|
|
#define R_NOIR 3
|
|
#define R_ROSE 4
|
|
#define R_CYAN 5
|
|
#define R_JAUNE 6
|
|
#define R_BLANC 7
|
|
|
|
#define LAYER_BELOW_RAYS 0
|
|
#define LAYER_ABOVE_RAYS 1
|
|
|
|
unsigned int SIZE = 16;
|
|
unsigned int OFFSET_X = 12;
|
|
unsigned int OFFSET_Y = 12;
|
|
|
|
unsigned int OFFSET_X_MINIMAP = 312;
|
|
unsigned int OFFSET_Y_MINIMAP = 160;
|
|
unsigned char SCALE_X_MINIMAP = 8;
|
|
unsigned char SCALE_Y_MINIMAP = 6;
|
|
|
|
unsigned char ALPHA_OPAQUE_DEFAULT = 80; //191
|
|
unsigned char ALPHA_TRANSPARENT_DEFAULT = 40; //62
|
|
|
|
unsigned char ALPHA_OPAQUE = ALPHA_OPAQUE_DEFAULT;
|
|
unsigned char ALPHA_TRANSPARENT = ALPHA_TRANSPARENT_DEFAULT;
|
|
unsigned char ALPHA_BLOQUE = 1;
|
|
|
|
unsigned char SPEEDUP_RAY = 1;
|
|
unsigned char SPEEDUP_WALL = 1;
|
|
|
|
char LEVELCOLOR=0;
|
|
|
|
const char* Revision = "Revision 1.0A";
|
|
const char* RevShort = "v1.0A";
|
|
|
|
|
|
static const uint16_t *filepath = u"\\\\fls0\\MgcLght.sav";
|
|
bool saveexist = false;
|
|
unsigned int sizeoffile;
|
|
GameSaveStatus sauvegarde;
|
|
LevelSaveStatus partielevel[33];
|
|
|
|
|
|
#define NB_LEVELS 32
|
|
|
|
|
|
unsigned char NbReceptorsLevel;
|
|
unsigned char NbDoorsLevel;
|
|
unsigned char NbBlocksLevel;
|
|
unsigned char NbTreasureLevel;
|
|
unsigned char NbObstacleLevel;
|
|
unsigned char NbMonsterLevel;
|
|
unsigned char NbBossLevel;
|
|
unsigned char NbBulletLevel;
|
|
|
|
selection selected = JOUEUR;
|
|
|
|
unsigned int score;
|
|
unsigned char life = 3;
|
|
unsigned char lifeMax = 5;
|
|
|
|
unsigned char SIZE_MAP_X=13;
|
|
unsigned char SIZE_MAP_Y=11;
|
|
|
|
Player joueur;
|
|
Light lumiere;
|
|
//MapItem carte[SIZE_MAP_X][SIZE_MAP_Y];
|
|
Wall murs[4];
|
|
|
|
Blocks* BlocRouge;
|
|
Blocks* BlocVert ;
|
|
Blocks* BlocBleu;
|
|
Blocks* BlocNoir;
|
|
|
|
|
|
Blocks* BlocksCollection=NULL;
|
|
Receptor* ReceptorCollection=NULL;
|
|
Door* DoorCollection=NULL;
|
|
Treasure* TreasureCollection=NULL;
|
|
Obstacle* ObstaclesCollection=NULL;
|
|
Monster* MonstersCollection=NULL;
|
|
Boss* BossCollection=NULL;
|
|
Bullet* BulletCollection=NULL;
|
|
|
|
|
|
Minimap Map[ 33 ];
|
|
|
|
|
|
unsigned char ALPHA_VALIDE = 255;
|
|
unsigned char ALPHA_NON_VALIDE = 100;
|
|
|
|
unsigned char EPSILON = 16;
|
|
|
|
extern bopti_image_t maintitle;
|
|
extern bopti_image_t leveltiles;
|
|
extern bopti_image_t sprites;
|
|
extern bopti_image_t player;
|
|
extern bopti_image_t light;
|
|
extern bopti_image_t cursor;
|
|
extern bopti_image_t parchemin;
|
|
extern bopti_image_t treasures;
|
|
extern bopti_image_t chests;
|
|
extern bopti_image_t monstres;
|
|
extern bopti_image_t hearts;
|
|
extern bopti_image_t bossmages;
|
|
extern bopti_image_t bigboss;
|
|
extern bopti_image_t bigparch;
|
|
extern bopti_image_t bulletsbicolor;
|
|
extern bopti_image_t fragments;
|
|
extern bopti_image_t village;
|
|
extern bopti_image_t castletitle;
|
|
extern bopti_image_t theend;
|
|
|
|
uint16_t palette[256];
|
|
|
|
bool BlackFrag=false;
|
|
bool WhiteFrag=false;
|
|
bool RedFrag=false;
|
|
bool GreenFrag=false;
|
|
bool BlueFrag=false;
|
|
|
|
|
|
extern font_t font_fantasy;
|
|
extern font_t font_tiny;
|
|
|
|
bool GotoMainMenu=false;
|
|
bool doneMain = false;
|
|
bool donePause = false;
|
|
bool doneOption = false;
|
|
bool doneGame = false;
|
|
bool doneStart = false;
|
|
bool doneTitle = false;
|
|
bool doneLoose = false;
|
|
bool doneDifficulty = false;
|
|
bool doneStory = false;
|
|
bool doneEnd = false;
|
|
bool attackboss = false;
|
|
|
|
unsigned int compteur_mouvement = 0;
|
|
unsigned char frame_cursor = 0;
|
|
unsigned char frame_light = 0;
|
|
unsigned char frame_monster = 0;
|
|
unsigned char frame_boss = 0;
|
|
unsigned char frame=0;
|
|
|
|
unsigned char frame_boss_attack=0;
|
|
unsigned int xbossattack;
|
|
unsigned int ybossattack;
|
|
unsigned char frame_bullet=0;
|
|
unsigned char attacktype;
|
|
unsigned char attackpattern;
|
|
|
|
bool mouvement=false;
|
|
orientations direction=HAUT;
|
|
|
|
unsigned char nextLevel;
|
|
unsigned char currentLevel;
|
|
unsigned char selectStartMenu = 0;
|
|
unsigned char selectDifficultyMenu = 0;
|
|
unsigned char selectOptionMenu = 0;
|
|
unsigned char selectOptionPause = 0;
|
|
unsigned char selectOptionLoose = 0;
|
|
unsigned char selectStoryMenu = 0;
|
|
unsigned char selectEndMenu = 0;
|
|
unsigned char difficulty = 0;
|
|
|
|
|
|
void is_save_existing( void )
|
|
{
|
|
int file = BFile_Open( filepath, BFile_ReadOnly );
|
|
if (file>=0)
|
|
{
|
|
saveexist=true;
|
|
BFile_Close( file );
|
|
}
|
|
else
|
|
{
|
|
saveexist=false;
|
|
BFile_Close( file );
|
|
}
|
|
}
|
|
|
|
bool is_save_existing_boolean( void )
|
|
{
|
|
int file = BFile_Open( filepath, BFile_ReadOnly );
|
|
if (file>=0)
|
|
{
|
|
BFile_Close( file );
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
BFile_Close( file );
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void delete_save( void )
|
|
{
|
|
BFile_Remove( filepath );
|
|
}
|
|
|
|
void saveprogress( void )
|
|
{
|
|
sizeoffile = sizeof( GameSaveStatus ) + 33*sizeof( LevelSaveStatus );
|
|
unsigned int sizecopy = sizeoffile;
|
|
|
|
unsigned char* buffer;
|
|
buffer = (unsigned char*) malloc( sizeoffile );
|
|
|
|
buffer[0] = sauvegarde.currentScore[0];
|
|
buffer[1] = sauvegarde.currentScore[1];
|
|
|
|
buffer[2] = sauvegarde.currentLevel;
|
|
|
|
for (unsigned char k = 0; k<=32; k++ )
|
|
buffer[3+k] = sauvegarde.visitedLevels[k];
|
|
|
|
buffer[36] = sauvegarde.currentDifficulty;
|
|
buffer[37] = sauvegarde.currentLife;
|
|
buffer[38] = sauvegarde.redFrag;
|
|
buffer[39] = sauvegarde.greenFrag;
|
|
buffer[40] = sauvegarde.blueFrag;
|
|
buffer[41] = sauvegarde.blackFrag;
|
|
buffer[42] = sauvegarde.whiteFrag;
|
|
buffer[43] = sauvegarde.terminator;
|
|
|
|
///TODO implement Room Saves
|
|
|
|
int index;
|
|
|
|
for (unsigned char k = 0; k<=32; k++ )
|
|
{
|
|
index = sizeof( GameSaveStatus )+k*sizeof( LevelSaveStatus );
|
|
|
|
//for( int i=0; i<8; i++ )
|
|
buffer[index+0] = partielevel[k].chestStatusSave[ 0 ];
|
|
buffer[index+1] = partielevel[k].chestStatusSave[ 1 ];
|
|
buffer[index+2] = partielevel[k].chestStatusSave[ 2 ];
|
|
buffer[index+3] = partielevel[k].chestStatusSave[ 3 ];
|
|
buffer[index+4] = partielevel[k].chestStatusSave[ 4 ];
|
|
buffer[index+5] = partielevel[k].chestStatusSave[ 5 ];
|
|
buffer[index+6] = partielevel[k].chestStatusSave[ 6 ];
|
|
buffer[index+7] = partielevel[k].chestStatusSave[ 7 ];
|
|
|
|
//for( unsigned char i=8; i<12; i++ )
|
|
buffer[index+8] = partielevel[k].doorStatusSave[ 0 ];
|
|
buffer[index+9] = partielevel[k].doorStatusSave[ 1 ];
|
|
buffer[index+10] = partielevel[k].doorStatusSave[ 2 ];
|
|
buffer[index+11] = partielevel[k].doorStatusSave[ 3 ];
|
|
|
|
//for( unsigned char i=12; i<20; i++ )
|
|
buffer[index+12] = partielevel[k].bossStatusSave[ 0 ];
|
|
buffer[index+13] = partielevel[k].bossStatusSave[ 1 ];
|
|
buffer[index+14] = partielevel[k].bossStatusSave[ 2 ];
|
|
buffer[index+15] = partielevel[k].bossStatusSave[ 3 ];
|
|
buffer[index+16] = partielevel[k].bossStatusSave[ 4 ];
|
|
buffer[index+17] = partielevel[k].bossStatusSave[ 5 ];
|
|
buffer[index+18] = partielevel[k].bossStatusSave[ 6 ];
|
|
buffer[index+19] = partielevel[k].bossStatusSave[ 7 ];
|
|
|
|
//for( unsigned char i=20; i<28; i++ )
|
|
buffer[index+20] = partielevel[k].monsterStatusSave[ 0 ];
|
|
buffer[index+21] = partielevel[k].monsterStatusSave[ 1 ];
|
|
buffer[index+22] = partielevel[k].monsterStatusSave[ 2 ];
|
|
buffer[index+23] = partielevel[k].monsterStatusSave[ 3 ];
|
|
buffer[index+24] = partielevel[k].monsterStatusSave[ 4 ];
|
|
buffer[index+25] = partielevel[k].monsterStatusSave[ 5 ];
|
|
buffer[index+26] = partielevel[k].monsterStatusSave[ 6 ];
|
|
buffer[index+27] = partielevel[k].monsterStatusSave[ 7 ];
|
|
|
|
//for( unsigned char i=28; i<30; i++ )
|
|
buffer[index+28] = partielevel[k].redBlockSave[ 0 ];
|
|
buffer[index+29] = partielevel[k].redBlockSave[ 1 ];
|
|
|
|
//for( unsigned char i=30; i<32; i++ )
|
|
buffer[index+30] = partielevel[k].greenBlockSave[ 0 ];
|
|
buffer[index+31] = partielevel[k].greenBlockSave[ 1 ];
|
|
|
|
//for( unsigned char i=32; i<34; i++ )
|
|
buffer[index+32] = partielevel[k].blueBlockSave[ 0 ];
|
|
buffer[index+33] = partielevel[k].blueBlockSave[ 1 ];
|
|
|
|
//for( unsigned char i=34; i<36; i++ )
|
|
buffer[index+34] = partielevel[k].blackBlockSave[ 0 ];
|
|
buffer[index+35] = partielevel[k].blackBlockSave[ 1 ];
|
|
|
|
//for( unsigned char i=36; i<38; i++ )
|
|
buffer[index+36] = partielevel[k].lightSave[ 0 ];
|
|
buffer[index+37] = partielevel[k].lightSave[ 1 ];
|
|
}
|
|
|
|
/*
|
|
int file = BFile_Open( filepath, BFile_ReadOnly );
|
|
|
|
if ( file >= 0 )
|
|
{
|
|
BFile_Close( file );
|
|
file = BFile_Remove( filepath );
|
|
}
|
|
|
|
|
|
*/
|
|
|
|
int file;
|
|
|
|
BFile_Remove( filepath );
|
|
BFile_Create( filepath, BFile_File, &sizecopy );
|
|
|
|
file = BFile_Open( filepath, BFile_WriteOnly );
|
|
BFile_Write( file, buffer, sizeoffile );
|
|
|
|
BFile_Close( file );
|
|
|
|
free( buffer );
|
|
}
|
|
|
|
void loadprogress( void )
|
|
{
|
|
sizeoffile = sizeof( GameSaveStatus ) + 33*sizeof( LevelSaveStatus );
|
|
unsigned int sizecopy = sizeoffile;
|
|
|
|
unsigned char* buffer;
|
|
buffer = (unsigned char*) malloc( sizeoffile );
|
|
|
|
|
|
int file;
|
|
file = BFile_Open( filepath, BFile_ReadOnly );
|
|
BFile_Read( file, buffer, sizeoffile, -1 );
|
|
BFile_Close( file );
|
|
|
|
|
|
sauvegarde.currentScore[0] = buffer[0];
|
|
sauvegarde.currentScore[1] = buffer[1];
|
|
|
|
sauvegarde.currentLevel = buffer[2];
|
|
|
|
for (unsigned char k = 0; k<=32; k++ )
|
|
sauvegarde.visitedLevels[k] = buffer[3+k];
|
|
|
|
sauvegarde.currentDifficulty = buffer[36];
|
|
sauvegarde.currentLife = buffer[37];
|
|
sauvegarde.redFrag = buffer[38];
|
|
sauvegarde.greenFrag = buffer[39];
|
|
sauvegarde.blueFrag = buffer[40];
|
|
sauvegarde.blackFrag = buffer[41];
|
|
sauvegarde.whiteFrag = buffer[42];
|
|
sauvegarde.terminator = buffer[43];
|
|
|
|
int index;
|
|
|
|
for (int k = 0; k<=32; k++ )
|
|
{
|
|
index = sizeof(GameSaveStatus)+k*sizeof( LevelSaveStatus );
|
|
|
|
//for( unsigned char i=0; i<8; i++ )
|
|
partielevel[k].chestStatusSave[ 0 ] = buffer[index+0];
|
|
partielevel[k].chestStatusSave[ 1 ] = buffer[index+1];
|
|
partielevel[k].chestStatusSave[ 2 ] = buffer[index+2];
|
|
partielevel[k].chestStatusSave[ 3 ] = buffer[index+3];
|
|
partielevel[k].chestStatusSave[ 4 ] = buffer[index+4];
|
|
partielevel[k].chestStatusSave[ 5 ] = buffer[index+5];
|
|
partielevel[k].chestStatusSave[ 6 ] = buffer[index+6];
|
|
partielevel[k].chestStatusSave[ 7 ] = buffer[index+7];
|
|
|
|
//for( unsigned char i=8; i<12; i++ )
|
|
partielevel[k].doorStatusSave[ 0 ] = buffer[index+8];
|
|
partielevel[k].doorStatusSave[ 1 ] = buffer[index+9];
|
|
partielevel[k].doorStatusSave[ 2 ] = buffer[index+10];
|
|
partielevel[k].doorStatusSave[ 3 ] = buffer[index+11];
|
|
|
|
//for( unsigned char i=12; i<20; i++ )
|
|
partielevel[k].bossStatusSave[ 0 ] = buffer[index+12];
|
|
partielevel[k].bossStatusSave[ 1 ] = buffer[index+13];
|
|
partielevel[k].bossStatusSave[ 2 ] = buffer[index+14];
|
|
partielevel[k].bossStatusSave[ 3 ] = buffer[index+15];
|
|
partielevel[k].bossStatusSave[ 4 ] = buffer[index+16];
|
|
partielevel[k].bossStatusSave[ 5 ] = buffer[index+17];
|
|
partielevel[k].bossStatusSave[ 6 ] = buffer[index+18];
|
|
partielevel[k].bossStatusSave[ 7 ] = buffer[index+19];
|
|
|
|
//for( unsigned char i=20; i<28; i++ )
|
|
partielevel[k].monsterStatusSave[ 0 ] = buffer[index+20];
|
|
partielevel[k].monsterStatusSave[ 1 ] = buffer[index+21];
|
|
partielevel[k].monsterStatusSave[ 2 ] = buffer[index+22];
|
|
partielevel[k].monsterStatusSave[ 3 ] = buffer[index+23];
|
|
partielevel[k].monsterStatusSave[ 4 ] = buffer[index+24];
|
|
partielevel[k].monsterStatusSave[ 5 ] = buffer[index+25];
|
|
partielevel[k].monsterStatusSave[ 6 ] = buffer[index+26];
|
|
partielevel[k].monsterStatusSave[ 7 ] = buffer[index+27];
|
|
|
|
//for( unsigned char i=28; i<30; i++ )
|
|
partielevel[k].redBlockSave[ 0 ] = buffer[index+28];
|
|
partielevel[k].redBlockSave[ 1 ] = buffer[index+29];
|
|
|
|
//for( unsigned char i=30; i<32; i++ )
|
|
partielevel[k].greenBlockSave[ 0 ] = buffer[index+30];
|
|
partielevel[k].greenBlockSave[ 1 ] = buffer[index+31];
|
|
|
|
//for( unsigned char i=32; i<34; i++ )
|
|
partielevel[k].blueBlockSave[ 0 ] = buffer[index+32];
|
|
partielevel[k].blueBlockSave[ 1 ] = buffer[index+33];
|
|
|
|
//for( unsigned char i=34; i<36; i++ )
|
|
partielevel[k].blackBlockSave[ 0 ] = buffer[index+34];
|
|
partielevel[k].blackBlockSave[ 1 ] = buffer[index+35];
|
|
|
|
//for( unsigned char i=36; i<38; i++ )
|
|
partielevel[k].lightSave[ 0 ] = buffer[index+36];
|
|
partielevel[k].lightSave[ 1 ] = buffer[index+37];
|
|
}
|
|
|
|
free( buffer );
|
|
|
|
}
|
|
|
|
void updateCurrentState( void )
|
|
{
|
|
sauvegarde.currentScore[0] = score/256;
|
|
sauvegarde.currentScore[1] = score%256;
|
|
sauvegarde.currentLevel = currentLevel;
|
|
|
|
for( unsigned char k=0; k<=32; k++ )
|
|
if (Map[k].visited==true) sauvegarde.visitedLevels[k] = 1;
|
|
else sauvegarde.visitedLevels[k] = 0;
|
|
|
|
sauvegarde.currentDifficulty = difficulty;
|
|
sauvegarde.currentLife = life;
|
|
|
|
if (RedFrag==true) sauvegarde.redFrag=true;
|
|
else sauvegarde.redFrag=false;
|
|
|
|
if (GreenFrag==true) sauvegarde.greenFrag=true;
|
|
else sauvegarde.greenFrag=false;
|
|
|
|
if (BlueFrag==true) sauvegarde.blueFrag=true;
|
|
else sauvegarde.blueFrag=false;
|
|
|
|
if (BlackFrag==true) sauvegarde.blackFrag=true;
|
|
else sauvegarde.blackFrag=false;
|
|
|
|
if (WhiteFrag==true) sauvegarde.whiteFrag=true;
|
|
else sauvegarde.whiteFrag=false;
|
|
|
|
|
|
for( unsigned char i=0; i<NbTreasureLevel; i++ )
|
|
if (TreasureCollection[i].isopen==false && TreasureCollection[i].isvisible==true)
|
|
partielevel[currentLevel].chestStatusSave[i]=0x00;
|
|
else if (TreasureCollection[i].isopen==true && TreasureCollection[i].isvisible==true)
|
|
partielevel[currentLevel].chestStatusSave[i]=0x01;
|
|
else if (TreasureCollection[i].isvisible==false)
|
|
partielevel[currentLevel].chestStatusSave[i]=0x02;
|
|
|
|
|
|
for( unsigned char i=0; i<NbDoorsLevel; i++ )
|
|
if (DoorCollection[i].isopen==true)
|
|
partielevel[currentLevel].doorStatusSave[i]=0x01;
|
|
else
|
|
partielevel[currentLevel].doorStatusSave[i]=0x00;
|
|
|
|
|
|
//TODO : save boss status
|
|
//for( int i=0; i<NbBossLevel; i++ )
|
|
|
|
//TODO : save monster status
|
|
//for( int i=0; i<NbMonsterLevel; i++ )
|
|
|
|
partielevel[currentLevel].redBlockSave[0]=BlocRouge->x;
|
|
partielevel[currentLevel].redBlockSave[1]=BlocRouge->y;
|
|
|
|
partielevel[currentLevel].greenBlockSave[0]=BlocVert->x;
|
|
partielevel[currentLevel].greenBlockSave[1]=BlocVert->y;
|
|
|
|
partielevel[currentLevel].blueBlockSave[0]=BlocBleu->x;
|
|
partielevel[currentLevel].blueBlockSave[1]=BlocBleu->y;
|
|
|
|
partielevel[currentLevel].blackBlockSave[0]=BlocNoir->x;
|
|
partielevel[currentLevel].blackBlockSave[1]=BlocNoir->y;
|
|
|
|
partielevel[currentLevel].lightSave[0]=lumiere.x;
|
|
partielevel[currentLevel].lightSave[1]=lumiere.y;
|
|
}
|
|
|
|
void initMap( void )
|
|
{
|
|
for( unsigned char k=0; k < 33; k++) Map[k].visited = false;
|
|
currentLevel = 0;
|
|
}
|
|
|
|
void adjustLevel( int lev )
|
|
{
|
|
|
|
for( int i=0; i<NbTreasureLevel; i++ )
|
|
if (partielevel[lev].chestStatusSave[i]==0)
|
|
{
|
|
TreasureCollection[i].isopen = false;
|
|
TreasureCollection[i].isvisible = true;
|
|
}
|
|
else if (partielevel[lev].chestStatusSave[i]==1)
|
|
{
|
|
TreasureCollection[i].isopen = true;
|
|
TreasureCollection[i].isvisible = true;
|
|
}
|
|
else if (partielevel[lev].chestStatusSave[i]==2)
|
|
{
|
|
TreasureCollection[i].isopen = true;
|
|
TreasureCollection[i].isvisible = false;
|
|
}
|
|
|
|
for( int i=0; i<NbDoorsLevel; i++ )
|
|
if (partielevel[lev].doorStatusSave[i]==1) DoorCollection[i].isopen=true;
|
|
else DoorCollection[i].isopen = false;
|
|
|
|
for( int i=0; i<NbBossLevel; i++ )
|
|
{
|
|
//TODO : make appropriate code
|
|
}
|
|
|
|
for( int i=0; i<NbMonsterLevel; i++ )
|
|
{
|
|
//TODO : make appropriate code
|
|
}
|
|
|
|
BlocRouge->x = partielevel[lev].redBlockSave[0];
|
|
BlocRouge->y = partielevel[lev].redBlockSave[1];
|
|
|
|
BlocVert->x = partielevel[lev].greenBlockSave[0];
|
|
BlocVert->y = partielevel[lev].greenBlockSave[1];
|
|
|
|
BlocBleu->x = partielevel[lev].blueBlockSave[0];
|
|
BlocBleu->y = partielevel[lev].blueBlockSave[1];
|
|
|
|
BlocNoir->x = partielevel[lev].blackBlockSave[0];
|
|
BlocNoir->y = partielevel[lev].blackBlockSave[1];
|
|
|
|
lumiere.x = partielevel[lev].lightSave[0];
|
|
lumiere.y = partielevel[lev].lightSave[1];
|
|
|
|
}
|
|
|
|
|
|
void loadLevel( unsigned char numLevel )
|
|
{
|
|
free(BlocksCollection);
|
|
free(ReceptorCollection);
|
|
free(DoorCollection);
|
|
free(TreasureCollection);
|
|
free(ObstaclesCollection);
|
|
free(MonstersCollection);
|
|
|
|
BlocksCollection=NULL;
|
|
ReceptorCollection=NULL;
|
|
DoorCollection=NULL;
|
|
TreasureCollection=NULL;
|
|
ObstaclesCollection=NULL;
|
|
MonstersCollection=NULL;
|
|
|
|
attackboss=false;
|
|
bool needcorrection=false;
|
|
|
|
|
|
|
|
// if (sauvegarde.visitedLevels[numLevel]==1) // The level to be loaded has already been played so we will have to make corrections as per save state
|
|
if (Map[numLevel].visited==true) needcorrection = true;
|
|
else needcorrection = false;
|
|
|
|
if (numLevel==0) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 0;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 4;
|
|
NbDoorsLevel = 1;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 0;
|
|
NbObstacleLevel = 16;
|
|
NbMonsterLevel = 0;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=0;
|
|
Map[numLevel].y=0;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=false;
|
|
Map[numLevel].doorNorth=true;
|
|
Map[numLevel].doorEast=false;
|
|
Map[numLevel].doorSouth=false;
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
ObstaclesCollection[0] = {4,1,BLOCK_STONE};
|
|
ObstaclesCollection[1] = {8,1,BLOCK_STONE};
|
|
ObstaclesCollection[2] = {1,3,BLOCK_STONE};
|
|
ObstaclesCollection[3] = {11,3,BLOCK_STONE};
|
|
ObstaclesCollection[4] = {1,7,BLOCK_STONE};
|
|
ObstaclesCollection[5] = {11,7,BLOCK_STONE};
|
|
ObstaclesCollection[6] = {4,9,BLOCK_STONE};
|
|
ObstaclesCollection[7] = {8,9,BLOCK_STONE};
|
|
|
|
ObstaclesCollection[8] = {5,4,BLOCK_WATER};
|
|
ObstaclesCollection[9] = {6,4,BLOCK_WATER};
|
|
ObstaclesCollection[10] = {7,4,BLOCK_WATER};
|
|
ObstaclesCollection[11] = {5,5,BLOCK_WATER};
|
|
ObstaclesCollection[12] = {7,5,BLOCK_WATER};
|
|
ObstaclesCollection[13] = {5,6,BLOCK_WATER};
|
|
ObstaclesCollection[14] = {6,6,BLOCK_WATER};
|
|
ObstaclesCollection[15] = {7,6,BLOCK_WATER};
|
|
|
|
|
|
BlocksCollection[0] = { 2, 4, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 10, 4, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 10, 6, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 2, 6, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
ReceptorCollection[0] = { 2, 0, BAS, 255, 0, 0, false }; // Receptor RED
|
|
ReceptorCollection[1] = { 10, 0, BAS, 0, 255, 0, false }; // Receptor GREEN
|
|
ReceptorCollection[2] = { 10, 10, HAUT, 0, 0, 255, false }; // Receptor BLUE
|
|
ReceptorCollection[3] = { 2, 10, HAUT, 0, 0, 0, false }; // Receptor BLACK
|
|
// ReceptorCollection[4] = { 8, 0, BAS, 255, 0, 255, false }; // Receptor PINK
|
|
// ReceptorCollection[5] = { 9, 10, HAUT, 0, 255, 255, false }; // Receptor CYAN
|
|
// ReceptorCollection[6] = { 12, 8, GAUCHE, 255, 255, 0, false }; // Receptor YELLOW
|
|
// ReceptorCollection[7] = { 0, 7, DROITE, 255, 255, 255, false }; // Receptor WHITE
|
|
|
|
DoorCollection[0] = { 6,0, HAUT, false, true, 1, { R_ROUGE, -1, -1 }, 2}; // Door NORTH
|
|
//DoorCollection[1] = { 0, 5, GAUCHE, false, true, 1, { R_BLEU, -1, -1 }, 0}; // Door WEST
|
|
//DoorCollection[2] = { 12, 5, DROITE, false, true, 1, { R_VERT, -1, -1 }, 0}; // Door EAST
|
|
//DoorCollection[3] = { 6, 10, BAS, false, false, 0, { -1 -1, -1 }, -1}; // Door SOUTH
|
|
|
|
//TreasureCollection[0] = {1,1, T_RED, false, WHITE_FRAGMENT, 100, true };
|
|
//TreasureCollection[1] = {2,1, T_YELLOW, false, BLACK_FRAGMENT, 100, true };
|
|
//TreasureCollection[2] = {3,1, T_GREEN, false, RED_FRAGMENT, 100, true };
|
|
//TreasureCollection[3] = {4,1, T_BLUE, false, GREEN_FRAGMENT, 100, true };
|
|
//TreasureCollection[4] = {5,1, T_BLUE, false, BLUE_FRAGMENT, 100, true };
|
|
|
|
//MonstersCollection[0] = { 6, 4, 2, 10, HORIZONTAL, GAUCHE, BLOB };
|
|
//MonstersCollection[1] = { 7, 5, 2, 8, VERTICAL, HAUT, SKELETON };
|
|
}
|
|
else if (numLevel==1) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 1;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 4;
|
|
NbDoorsLevel = 2;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 4;
|
|
NbObstacleLevel = 16;
|
|
NbMonsterLevel = 4;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=-1;
|
|
Map[numLevel].y=-1;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=false;
|
|
Map[numLevel].doorNorth=true;
|
|
Map[numLevel].doorEast=true;
|
|
Map[numLevel].doorSouth=false;
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
ObstaclesCollection[0] = {1,1,BLOCK_STONE};
|
|
ObstaclesCollection[1] = {11,1,BLOCK_STONE};
|
|
ObstaclesCollection[2] = {1,9,BLOCK_STONE};
|
|
ObstaclesCollection[3] = {11,9,BLOCK_STONE};
|
|
|
|
ObstaclesCollection[4] = {1,2,BLOCK_WATER};
|
|
ObstaclesCollection[5] = {2,1,BLOCK_WATER};
|
|
ObstaclesCollection[6] = {2,2,BLOCK_WATER};
|
|
|
|
ObstaclesCollection[7] = {10,1,BLOCK_WATER};
|
|
ObstaclesCollection[8] = {10,2,BLOCK_WATER};
|
|
ObstaclesCollection[9] = {11,2,BLOCK_WATER};
|
|
|
|
ObstaclesCollection[10] = {10,9,BLOCK_WATER};
|
|
ObstaclesCollection[11] = {10,8,BLOCK_WATER};
|
|
ObstaclesCollection[12] = {11,8,BLOCK_WATER};
|
|
|
|
ObstaclesCollection[13] = {1,8,BLOCK_WATER};
|
|
ObstaclesCollection[14] = {2,8,BLOCK_WATER};
|
|
ObstaclesCollection[15] = {2,9,BLOCK_WATER};
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
ReceptorCollection[0] = { 5, 0, BAS, 255, 0, 0, false }; // Receptor RED
|
|
ReceptorCollection[1] = { 12, 4, GAUCHE, 0, 255, 0, false }; // Receptor GREEN
|
|
ReceptorCollection[2] = { 0, 6, DROITE, 0, 0, 255, false }; // Receptor BLUE
|
|
ReceptorCollection[3] = { 6, 10, HAUT, 0, 0, 0, false }; // Receptor BLACK
|
|
// ReceptorCollection[4] = { 8, 0, BAS, 255, 0, 255, false }; // Receptor PINK
|
|
// ReceptorCollection[5] = { 9, 10, HAUT, 0, 255, 255, false }; // Receptor CYAN
|
|
// ReceptorCollection[6] = { 12, 8, GAUCHE, 255, 255, 0, false }; // Receptor YELLOW
|
|
// ReceptorCollection[7] = { 0, 7, DROITE, 255, 255, 255, false }; // Receptor WHITE
|
|
|
|
DoorCollection[0] = { 6,0, HAUT, false, true, 2, { R_ROUGE,R_BLEU, -1 }, 4}; // Door NORTH
|
|
//DoorCollection[1] = { 0, 5, GAUCHE, false, true, 1, { R_BLEU, -1, -1 }, 0}; // Door WEST
|
|
DoorCollection[1] = { 12, 5, DROITE, false, true, 2, { R_VERT, R_NOIR, -1 }, 2}; // Door EAST
|
|
//DoorCollection[3] = { 6, 10, BAS, false, false, 0, { -1 -1, -1 }, -1}; // Door SOUTH
|
|
|
|
TreasureCollection[0] = {4,4, T_RED, false, PIERRE_BLANCHE, 100, true };
|
|
TreasureCollection[1] = {8,4, T_YELLOW, false, PIERRE_BLANCHE, 100, true };
|
|
TreasureCollection[2] = {4,6, T_GREEN, false, PIERRE_BLANCHE, 100, true };
|
|
TreasureCollection[3] = {8,6, T_BLUE, false, PIERRE_BLANCHE, 100, true };
|
|
|
|
MonstersCollection[0] = { 6, 3, 1, 11, HORIZONTAL, DROITE, SPIDER };
|
|
MonstersCollection[1] = { 6, 7, 1, 11, HORIZONTAL, GAUCHE, SPIDER };
|
|
MonstersCollection[2] = { 3, 5, 1, 9, VERTICAL, HAUT, SPIDER };
|
|
MonstersCollection[3] = { 9, 5, 1, 9, VERTICAL, BAS, SPIDER };
|
|
//MonstersCollection[1] = { 1, 5, 1, 9, VERTICAL, BAS, SPIDER };
|
|
//MonstersCollection[2] = { 10, 5, 1, 9, VERTICAL, HAUT, GHOST };
|
|
|
|
}
|
|
else if (numLevel==2) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 2;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 4;
|
|
NbDoorsLevel = 3;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 4;
|
|
NbObstacleLevel = 24;
|
|
NbMonsterLevel = 0;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=0;
|
|
Map[numLevel].y=-1;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=true;
|
|
Map[numLevel].doorNorth=false;
|
|
Map[numLevel].doorEast=true;
|
|
Map[numLevel].doorSouth=true;
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
ObstaclesCollection[0] = {1,4,BLOCK_STONE};
|
|
ObstaclesCollection[1] = {2,4,BLOCK_STONE};
|
|
ObstaclesCollection[2] = {1,6,BLOCK_STONE};
|
|
ObstaclesCollection[3] = {2,6,BLOCK_STONE};
|
|
ObstaclesCollection[4] = {10,4,BLOCK_STONE};
|
|
ObstaclesCollection[5] = {11,4,BLOCK_STONE};
|
|
ObstaclesCollection[6] = {10,6,BLOCK_STONE};
|
|
ObstaclesCollection[7] = {11,6,BLOCK_STONE};
|
|
ObstaclesCollection[8] = {5,8,BLOCK_STONE};
|
|
ObstaclesCollection[9] = {5,9,BLOCK_STONE};
|
|
ObstaclesCollection[10] = {7,8,BLOCK_STONE};
|
|
ObstaclesCollection[11] = {7,9,BLOCK_STONE};
|
|
ObstaclesCollection[12] = {5,2,BLOCK_WATER};
|
|
ObstaclesCollection[13] = {6,2,BLOCK_WATER};
|
|
ObstaclesCollection[14] = {7,2,BLOCK_WATER};
|
|
ObstaclesCollection[15] = {5,3,BLOCK_WATER};
|
|
ObstaclesCollection[16] = {7,3,BLOCK_WATER};
|
|
ObstaclesCollection[17] = {5,4,BLOCK_WATER};
|
|
ObstaclesCollection[18] = {7,4,BLOCK_WATER};
|
|
ObstaclesCollection[19] = {5,5,BLOCK_WATER};
|
|
ObstaclesCollection[20] = {7,5,BLOCK_WATER};
|
|
ObstaclesCollection[21] = {5,6,BLOCK_WATER};
|
|
ObstaclesCollection[22] = {6,6,BLOCK_WATER};
|
|
ObstaclesCollection[23] = {7,6,BLOCK_WATER};
|
|
|
|
BlocksCollection[0] = { 2, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 3, 1, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 10, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 9, 1, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
ReceptorCollection[0] = { 0, 3, DROITE, 255, 0, 0, false }; // Receptor RED
|
|
ReceptorCollection[1] = { 2, 0, BAS, 0, 255, 0, false }; // Receptor GREEN
|
|
ReceptorCollection[2] = { 12, 3, GAUCHE, 0, 0, 255, false }; // Receptor BLUE
|
|
ReceptorCollection[3] = { 10, 0, BAS, 0, 0, 0, false }; // Receptor BLACK
|
|
//ReceptorCollection[4] = { 8, 0, BAS, 255, 0, 255, false }; // Receptor PINK
|
|
//ReceptorCollection[5] = { 9, 10, HAUT, 0, 255, 255, false }; // Receptor CYAN
|
|
//ReceptorCollection[6] = { 12, 8, GAUCHE, 255, 255, 0, false }; // Receptor YELLOW
|
|
//ReceptorCollection[7] = { 0, 7, DROITE, 255, 255, 255, false }; // Receptor WHITE
|
|
|
|
//DoorCollection[0] = { 6,0, HAUT, false, true, 1, { R_ROUGE,R_BLEU, R_VERT }, 1}; // Door NORTH
|
|
DoorCollection[0] = { 0, 5, GAUCHE, false, true, 2, { R_ROUGE, R_VERT, -1 }, 1}; // Door WEST
|
|
DoorCollection[1] = { 12, 5, DROITE, false, true, 2, { R_BLEU, R_NOIR, -1 }, 3}; // Door EAST
|
|
DoorCollection[2] = { 6, 10, BAS, false, true, 2, { R_ROUGE, R_BLEU, -1 }, 0}; // Door SOUTH
|
|
|
|
TreasureCollection[0] = {1,1, T_RED, false, PIERRE_BLANCHE, 100, true };
|
|
TreasureCollection[1] = {11,1, T_YELLOW, false, PIERRE_BLANCHE, 100, true };
|
|
TreasureCollection[2] = {1,9, T_GREEN, false, PIERRE_BLANCHE, 100, true };
|
|
TreasureCollection[3] = {11,9, T_BLUE, false, PIERRE_BLANCHE, 100, true };
|
|
|
|
}
|
|
else if (numLevel==3) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 1;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 4;
|
|
NbDoorsLevel = 2;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 4;
|
|
NbObstacleLevel = 8;
|
|
NbMonsterLevel = 4;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=1;
|
|
Map[numLevel].y=-1;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=true;
|
|
Map[numLevel].doorNorth=true;
|
|
Map[numLevel].doorEast=false;
|
|
Map[numLevel].doorSouth=false;
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
ObstaclesCollection[0] = {2,2,BLOCK_SUN};
|
|
ObstaclesCollection[1] = {10,2,BLOCK_SUN};
|
|
ObstaclesCollection[2] = {2,8,BLOCK_SUN};
|
|
ObstaclesCollection[3] = {10,8,BLOCK_SUN};
|
|
ObstaclesCollection[4] = {4,5,BLOCK_WATER};
|
|
ObstaclesCollection[5] = {8,5,BLOCK_WATER};
|
|
ObstaclesCollection[6] = {6,3,BLOCK_WATER};
|
|
ObstaclesCollection[7] = {6,7,BLOCK_WATER};
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
ReceptorCollection[0] = { 5, 0, BAS, 255, 0, 0, false }; // Receptor RED
|
|
ReceptorCollection[1] = { 12, 4, GAUCHE, 0, 255, 0, false }; // Receptor GREEN
|
|
ReceptorCollection[2] = { 0, 6, DROITE, 0, 0, 255, false }; // Receptor BLUE
|
|
ReceptorCollection[3] = { 12, 7, GAUCHE, 0, 0, 0, false }; // Receptor BLACK
|
|
//ReceptorCollection[4] = { 8, 0, BAS, 255, 0, 255, false }; // Receptor PINK
|
|
//ReceptorCollection[5] = { 9, 10, HAUT, 0, 255, 255, false }; // Receptor CYAN
|
|
//ReceptorCollection[3] = { 12, 8, GAUCHE, 255, 255, 0, false }; // Receptor YELLOW
|
|
//ReceptorCollection[7] = { 0, 7, DROITE, 255, 255, 255, false }; // Receptor WHITE
|
|
|
|
|
|
DoorCollection[0] = { 6,0, HAUT, false, true, 3, { R_ROUGE,R_BLEU, R_VERT }, 5}; // Door NORTH
|
|
DoorCollection[1] = { 0, 5, GAUCHE, false, true, 1, { R_BLEU, 3, -1 }, 2}; // Door WEST
|
|
//DoorCollection[2] = { 12, 5, DROITE, false, true, 1, { R_VERT, -1, -1 }, 0}; // Door EAST
|
|
//DoorCollection[3] = { 6, 10, BAS, false, false, 0, { -1 -1, -1 }, -1}; // Door SOUTH
|
|
|
|
TreasureCollection[0] = {4,4, T_RED, false, PIERRE_BLANCHE, 100, true };
|
|
TreasureCollection[1] = {8,4, T_YELLOW, false, PIERRE_BLANCHE, 100, true };
|
|
TreasureCollection[2] = {4,6, T_GREEN, false, PIERRE_BLANCHE, 100, true };
|
|
TreasureCollection[3] = {8,6, T_BLUE, false, PIERRE_BLANCHE, 100, true };
|
|
|
|
MonstersCollection[0] = { 6, 2, 1, 11, HORIZONTAL, DROITE, SKELETON };
|
|
MonstersCollection[1] = { 6, 8, 1, 11, HORIZONTAL, GAUCHE, SKELETON };
|
|
MonstersCollection[2] = { 2, 5, 1, 9, VERTICAL, HAUT, SKELETON };
|
|
MonstersCollection[3] = { 10, 5, 1, 9, VERTICAL, BAS, SKELETON };
|
|
|
|
|
|
}
|
|
else if (numLevel==4) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 1;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 5;
|
|
NbDoorsLevel = 2;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 4;
|
|
NbObstacleLevel = 4;
|
|
NbMonsterLevel = 0;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=-1;
|
|
Map[numLevel].y=-2;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=false;
|
|
Map[numLevel].doorNorth=true;
|
|
Map[numLevel].doorEast=false;
|
|
Map[numLevel].doorSouth=true;
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 6, 1,1,1,0, false };
|
|
|
|
//ObstaclesCollection[0] = {2,2,BLOCK_SUN};
|
|
//ObstaclesCollection[1] = {10,2,BLOCK_SUN};
|
|
//ObstaclesCollection[2] = {2,8,BLOCK_SUN};
|
|
//ObstaclesCollection[3] = {10,8,BLOCK_SUN};
|
|
ObstaclesCollection[0] = {5,6,BLOCK_WATER};
|
|
ObstaclesCollection[1] = {7,6,BLOCK_WATER};
|
|
ObstaclesCollection[2] = {6,5,BLOCK_WATER};
|
|
ObstaclesCollection[3] = {6,7,BLOCK_WATER};
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
ReceptorCollection[0] = { 5, 0, BAS, 255, 0, 0, false }; // Receptor RED
|
|
ReceptorCollection[1] = { 12, 4, GAUCHE, 0, 255, 0, false }; // Receptor GREEN
|
|
ReceptorCollection[2] = { 0, 6, DROITE, 0, 0, 255, false }; // Receptor BLUE
|
|
ReceptorCollection[3] = { 12, 8, GAUCHE, 0, 0, 0, false }; // Receptor BLACK
|
|
ReceptorCollection[4] = { 12, 3, GAUCHE, 255, 255, 0, false }; // Receptor PINK
|
|
// ReceptorCollection[5] = { 9, 10, HAUT, 0, 255, 255, false }; // Receptor CYAN
|
|
// ReceptorCollection[6] = { 12, 8, GAUCHE, 255, 255, 0, false }; // Receptor YELLOW
|
|
// ReceptorCollection[7] = { 0, 7, DROITE, 255, 255, 255, false }; // Receptor WHITE
|
|
|
|
DoorCollection[0] = { 6,0, HAUT, false, true, 2, { 2,4, -1 }, 7}; // Door NORTH
|
|
//DoorCollection[1] = { 0, 5, GAUCHE, false, true, 1, { R_BLEU, -1, -1 }, 0}; // Door WEST
|
|
//DoorCollection[2] = { 12, 5, DROITE, false, true, 1, { R_VERT, -1, -1 }, 0}; // Door EAST
|
|
DoorCollection[1] = { 6, 10, BAS, false, true, 1, { R_NOIR, -1, -1 }, 1}; // Door SOUTH
|
|
|
|
TreasureCollection[0] = {1,1, T_RED, false, PIERRE_BLANCHE, 100, true };
|
|
TreasureCollection[1] = {11,1, T_YELLOW, false, PIERRE_BLANCHE, 100, true };
|
|
TreasureCollection[2] = {11,9, T_GREEN, false, PIERRE_BLANCHE, 100, true };
|
|
TreasureCollection[3] = {1,9, T_BLUE, false, PIERRE_BLANCHE, 100, true };
|
|
|
|
//BossCollection[0] = { 6, 2, 2, 10, HORIZONTAL, GAUCHE, B_RED };
|
|
//BossCollection[1] = { 2, 5, 2, 8, VERTICAL, HAUT, B_GREEN };
|
|
//BossCollection[2] = { 6, 9, 2, 10, HORIZONTAL, GAUCHE, B_BLUE };
|
|
//BossCollection[3] = { 10, 5, 2, 8, VERTICAL, HAUT, B_BLACK };
|
|
|
|
}
|
|
else if (numLevel==5) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 1;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 4;
|
|
NbDoorsLevel = 2;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 4;
|
|
NbObstacleLevel = 8;
|
|
NbMonsterLevel = 0;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=1;
|
|
Map[numLevel].y=-2;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=false;
|
|
Map[numLevel].doorNorth=true;
|
|
Map[numLevel].doorEast=false;
|
|
Map[numLevel].doorSouth=true;
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 6, 1,1,1,0, false };
|
|
|
|
ObstaclesCollection[0] = {6,3,BLOCK_SUN};
|
|
ObstaclesCollection[1] = {5,4,BLOCK_WATER};
|
|
ObstaclesCollection[2] = {7,4,BLOCK_WATER};
|
|
ObstaclesCollection[3] = {5,5,BLOCK_SUN};
|
|
ObstaclesCollection[4] = {7,5,BLOCK_SUN};
|
|
ObstaclesCollection[5] = {5,6,BLOCK_WATER};
|
|
ObstaclesCollection[6] = {7,6,BLOCK_WATER};
|
|
ObstaclesCollection[7] = {6,7,BLOCK_SUN};
|
|
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
ReceptorCollection[0] = { 8, 0, BAS, 255, 0, 0, false }; // Receptor RED
|
|
ReceptorCollection[1] = { 4, 10, HAUT, 0, 255, 0, false }; // Receptor GREEN
|
|
ReceptorCollection[2] = { 4, 0, BAS, 0, 0, 255, false }; // Receptor BLUE
|
|
ReceptorCollection[3] = { 8, 10, HAUT, 0, 0, 0, false }; // Receptor BLACK
|
|
// ReceptorCollection[4] = { 12, 3, GAUCHE, 255, 0, 255, false }; // Receptor PINK
|
|
// ReceptorCollection[5] = { 9, 10, HAUT, 0, 255, 255, false }; // Receptor CYAN
|
|
// ReceptorCollection[6] = { 12, 8, GAUCHE, 255, 255, 0, false }; // Receptor YELLOW
|
|
// ReceptorCollection[7] = { 0, 7, DROITE, 255, 255, 255, false }; // Receptor WHITE
|
|
|
|
DoorCollection[0] = { 6,0, HAUT, false, true, 2, { 0, 2, -1 }, 9}; // Door NORTH
|
|
//DoorCollection[1] = { 0, 5, GAUCHE, false, true, 1, { R_BLEU, -1, -1 }, 0}; // Door WEST
|
|
//DoorCollection[2] = { 12, 5, DROITE, false, true, 1, { R_VERT, -1, -1 }, 0}; // Door EAST
|
|
DoorCollection[1] = { 6, 10, BAS, false, true, 2, { 1, 3, -1 }, 3}; // Door SOUTH
|
|
|
|
TreasureCollection[0] = {1,1, T_RED, false, PIERRE_BLANCHE, 100, true };
|
|
TreasureCollection[1] = {11,1, T_YELLOW, false, PIERRE_BLANCHE, 100, true };
|
|
TreasureCollection[2] = {11,9, T_GREEN, false, PIERRE_BLANCHE, 100, true };
|
|
TreasureCollection[3] = {1,9, T_BLUE, false, PIERRE_BLANCHE, 100, true };
|
|
|
|
//BossCollection[0] = { 6, 2, 2, 10, HORIZONTAL, GAUCHE, B_RED };
|
|
//BossCollection[1] = { 2, 5, 2, 8, VERTICAL, HAUT, B_GREEN };
|
|
//BossCollection[2] = { 6, 9, 2, 10, HORIZONTAL, GAUCHE, B_BLUE };
|
|
//BossCollection[3] = { 10, 5, 2, 8, VERTICAL, HAUT, B_BLACK };
|
|
}
|
|
else if (numLevel==6) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 2;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 4;
|
|
NbDoorsLevel = 2;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 0;
|
|
NbObstacleLevel = 8;
|
|
NbMonsterLevel = 8;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=-2;
|
|
Map[numLevel].y=-3;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=false;
|
|
Map[numLevel].doorNorth=true;
|
|
Map[numLevel].doorEast=true;
|
|
Map[numLevel].doorSouth=false;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
DoorCollection[0] = { 6,0, HAUT, false, true, 3, { 0,1,2 }, 11}; // Door NORTH
|
|
//DoorCollection[1] = { 0, 5, GAUCHE, false, true, 0, { -1, -1, -1 }, 0}; // Door WEST
|
|
DoorCollection[1] = { 12, 5, DROITE, false, true, 1, { 3, -1, -1 }, 7}; // Door EAST
|
|
//DoorCollection[1] = { 6, 10, BAS, false, true, 0, { -1, -1, -1 }, 0}; // Door SOUTH
|
|
|
|
ObstaclesCollection[0] = {5,4,BLOCK_WATER};
|
|
ObstaclesCollection[1] = {5,5,BLOCK_WATER};
|
|
ObstaclesCollection[2] = {5,6,BLOCK_WATER};
|
|
ObstaclesCollection[3] = {6,6,BLOCK_WATER};
|
|
ObstaclesCollection[4] = {7,6,BLOCK_WATER};
|
|
ObstaclesCollection[5] = {7,5,BLOCK_WATER};
|
|
ObstaclesCollection[6] = {7,4,BLOCK_WATER};
|
|
ObstaclesCollection[7] = {6,4,BLOCK_WATER};
|
|
|
|
ReceptorCollection[0] = { 5, 0, BAS, 255, 0, 0, false }; // Receptor RED
|
|
ReceptorCollection[1] = { 0, 5, DROITE, 0, 255, 0, false }; // Receptor GREEN
|
|
ReceptorCollection[2] = { 12, 4, GAUCHE, 0, 0, 255, false }; // Receptor BLUE
|
|
ReceptorCollection[3] = { 6, 10, HAUT, 0, 0, 0, false }; // Receptor BLACK
|
|
// ReceptorCollection[4] = { 12, 3, GAUCHE, 255, 0, 255, false }; // Receptor PINK
|
|
// ReceptorCollection[5] = { 9, 10, HAUT, 0, 255, 255, false }; // Receptor CYAN
|
|
// ReceptorCollection[6] = { 12, 8, GAUCHE, 255, 255, 0, false }; // Receptor YELLOW
|
|
// ReceptorCollection[7] = { 0, 7, DROITE, 255, 255, 255, false }; // Receptor WHITE
|
|
|
|
MonstersCollection[0] = { 5, 3, 1, 5, HORIZONTAL, GAUCHE, BLOB };
|
|
MonstersCollection[1] = { 5, 2, 1, 5, HORIZONTAL, GAUCHE, BLOB };
|
|
MonstersCollection[2] = { 7, 3, 7, 11, HORIZONTAL, DROITE, BLOB };
|
|
MonstersCollection[3] = { 7, 2, 7, 11, HORIZONTAL, DROITE, BLOB };
|
|
MonstersCollection[4] = { 5, 7, 1, 5, HORIZONTAL, GAUCHE, BLOB };
|
|
MonstersCollection[5] = { 5, 8, 1, 5, HORIZONTAL, GAUCHE, BLOB };
|
|
MonstersCollection[6] = { 7, 7, 7, 11, HORIZONTAL, DROITE, BLOB };
|
|
MonstersCollection[7] = { 7, 8, 7, 11, HORIZONTAL, DROITE, BLOB };
|
|
|
|
|
|
}
|
|
else if (numLevel==7) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 0;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 6;
|
|
NbDoorsLevel = 3;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 0;
|
|
NbObstacleLevel = 7;
|
|
NbMonsterLevel = 0;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=-1;
|
|
Map[numLevel].y=-3;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=true;
|
|
Map[numLevel].doorNorth=false;
|
|
Map[numLevel].doorEast=true;
|
|
Map[numLevel].doorSouth=true;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 7, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
ReceptorCollection[0] = { 12, 3, GAUCHE, 255, 0, 0, false }; // Receptor RED
|
|
ReceptorCollection[1] = { 6, 0, BAS, 0, 255, 0, false }; // Receptor GREEN
|
|
ReceptorCollection[2] = { 0, 3, DROITE, 0, 0, 255, false }; // Receptor BLUE
|
|
ReceptorCollection[3] = { 11, 10, HAUT, 0, 0, 0, false }; // Receptor BLACK
|
|
//ReceptorCollection[4] = { 12, 3, GAUCHE, 255, 0, 255, false }; // Receptor PINK
|
|
ReceptorCollection[4] = { 1, 0, BAS, 0, 255, 255, false }; // Receptor CYAN
|
|
ReceptorCollection[5] = { 11, 0, BAS, 255, 255, 0, false }; // Receptor YELLOW
|
|
// ReceptorCollection[7] = { 0, 7, DROITE, 255, 255, 255, false }; // Receptor WHITE
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
//DoorCollection[0] = { 6,0, HAUT, false, true, 0, { -1,-1, -1 }, 11}; // Door NORTH
|
|
DoorCollection[0] = { 0, 5, GAUCHE, false, true, 2, { 2, 0, -1 }, 6}; // Door WEST
|
|
DoorCollection[1] = { 12, 5, DROITE, false, true, 3, { 1, 5, 4 }, 8}; // Door EAST
|
|
DoorCollection[2] = { 6, 10, BAS, false, true, 1, { 3, -1, -1 }, 4}; // Door SOUTH
|
|
|
|
ObstaclesCollection[0] = {5,6,BLOCK_WATER};
|
|
//ObstaclesCollection[1] = {6,6,BLOCK_WATER};
|
|
ObstaclesCollection[1] = {7,6,BLOCK_WATER};
|
|
ObstaclesCollection[2] = {5,7,BLOCK_WATER};
|
|
ObstaclesCollection[3] = {7,7,BLOCK_WATER};
|
|
ObstaclesCollection[4] = {5,8,BLOCK_WATER};
|
|
ObstaclesCollection[5] = {6,8,BLOCK_WATER};
|
|
ObstaclesCollection[6] = {7,8,BLOCK_WATER};
|
|
|
|
}
|
|
else if (numLevel==8) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 2;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 5;
|
|
NbDoorsLevel = 3;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 0;
|
|
NbObstacleLevel = 0;
|
|
NbMonsterLevel = 0;
|
|
NbBossLevel = 1;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=0;
|
|
Map[numLevel].y=-3;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=true;
|
|
Map[numLevel].doorNorth=true;
|
|
Map[numLevel].doorEast=true;
|
|
Map[numLevel].doorSouth=false;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
DoorCollection[0] = { 6,0, HAUT, false, true, 3, { 2,3,4 },12}; // Door NORTH
|
|
DoorCollection[1] = { 0, 5, GAUCHE, false, true, 3, { 1, 4, 2 }, 7}; // Door WEST
|
|
DoorCollection[2] = { 12, 5, DROITE, false, true, 3, { 0, 3, 2 }, 9}; // Door EAST
|
|
//DoorCollection[2] = { 6, 10, BAS, false, true, 0, { -1, -1, -1 }, 4}; // Door SOUTH
|
|
|
|
|
|
ReceptorCollection[0] = { 12, 8, GAUCHE, 255, 0, 0, false }; // Receptor RED
|
|
ReceptorCollection[1] = { 0, 8, DROITE, 0, 255, 0, false }; // Receptor GREEN
|
|
//ReceptorCollection[2] = { 0, 6, DROITE, 0, 0, 255, false }; // Receptor BLUE
|
|
ReceptorCollection[2] = { 6, 10, HAUT, 0, 0, 0, false }; // Receptor BLACK
|
|
ReceptorCollection[3] = { 9, 10, HAUT, 255, 0, 255, false }; // Receptor PINK
|
|
ReceptorCollection[4] = { 3, 10, HAUT, 0, 255, 255, false }; // Receptor CYAN
|
|
// ReceptorCollection[6] = { 12, 8, GAUCHE, 255, 255, 0, false }; // Receptor YELLOW
|
|
// ReceptorCollection[7] = { 0, 7, DROITE, 255, 255, 255, false }; // Receptor WHITE
|
|
|
|
|
|
|
|
BossCollection[0] = { 6, 3, 2, 10, HORIZONTAL, GAUCHE, B_RED };
|
|
|
|
}
|
|
else if (numLevel==9) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 0;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 6;
|
|
NbDoorsLevel = 3;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 0;
|
|
NbObstacleLevel = 7;
|
|
NbMonsterLevel = 0;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=1;
|
|
Map[numLevel].y=-3;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=true;
|
|
Map[numLevel].doorNorth=false;
|
|
Map[numLevel].doorEast=true;
|
|
Map[numLevel].doorSouth=true;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 7, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
ReceptorCollection[0] = { 3, 0, BAS, 255, 0, 255, false }; // Receptor RED
|
|
ReceptorCollection[1] = { 6, 0, BAS, 255, 0, 0, false }; // Receptor GREEN
|
|
ReceptorCollection[2] = { 9, 0, BAS, 255, 255, 0, false }; // Receptor BLUE
|
|
ReceptorCollection[3] = { 11, 10, HAUT, 0, 0, 0, false }; // Receptor BLACK
|
|
//ReceptorCollection[4] = { 12, 3, GAUCHE, 255, 0, 255, false }; // Receptor PINK
|
|
ReceptorCollection[4] = { 1, 0, BAS, 255, 0, 0, false }; // Receptor CYAN
|
|
ReceptorCollection[5] = { 11, 0, BAS, 255, 0, 0, false }; // Receptor YELLOW
|
|
// ReceptorCollection[7] = { 0, 7, DROITE, 255, 255, 255, false }; // Receptor WHITE
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
//DoorCollection[0] = { 6,0, HAUT, false, true, 0, { -1,-1, -1 }, 11}; // Door NORTH
|
|
DoorCollection[0] = { 0, 5, GAUCHE, false, true, 3, { 0, 2, 1 }, 8}; // Door WEST
|
|
DoorCollection[1] = { 12, 5, DROITE, false, true, 3, { 1, 4, 5 }, 10}; // Door EAST
|
|
DoorCollection[2] = { 6, 10, BAS, false, true, 1, { 3, -1, -1 }, 5}; // Door SOUTH
|
|
|
|
ObstaclesCollection[0] = {5,6,BLOCK_WATER};
|
|
ObstaclesCollection[1] = {7,6,BLOCK_WATER};
|
|
ObstaclesCollection[2] = {5,7,BLOCK_WATER};
|
|
ObstaclesCollection[3] = {7,7,BLOCK_WATER};
|
|
ObstaclesCollection[4] = {5,8,BLOCK_WATER};
|
|
ObstaclesCollection[5] = {6,8,BLOCK_WATER};
|
|
ObstaclesCollection[6] = {7,8,BLOCK_WATER};
|
|
|
|
}
|
|
else if (numLevel==10) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 0;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 4;
|
|
NbDoorsLevel = 2;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 0;
|
|
NbObstacleLevel = 8;
|
|
NbMonsterLevel = 8;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=2;
|
|
Map[numLevel].y=-3;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=true;
|
|
Map[numLevel].doorNorth=true;
|
|
Map[numLevel].doorEast=false;
|
|
Map[numLevel].doorSouth=false;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
DoorCollection[0] = { 6,0, HAUT, false, true, 3, { 0,1,2 },13}; // Door NORTH
|
|
DoorCollection[1] = { 0, 5, GAUCHE, false, true, 1, { 3, -1, -1 }, 9}; // Door WEST
|
|
//DoorCollection[1] = { 12, 5, DROITE, false, true, 0, { -1, -1, -1 }, 10}; // Door EAST
|
|
//DoorCollection[2] = { 6, 10, BAS, false, true, 0, { -1, -1, -1 }, 5}; // Door SOUTH
|
|
|
|
ObstaclesCollection[0] = {5,4,BLOCK_WATER};
|
|
ObstaclesCollection[1] = {5,5,BLOCK_WATER};
|
|
ObstaclesCollection[2] = {5,6,BLOCK_WATER};
|
|
ObstaclesCollection[3] = {6,6,BLOCK_WATER};
|
|
ObstaclesCollection[4] = {7,6,BLOCK_WATER};
|
|
ObstaclesCollection[5] = {7,5,BLOCK_WATER};
|
|
ObstaclesCollection[6] = {7,4,BLOCK_WATER};
|
|
ObstaclesCollection[7] = {6,4,BLOCK_WATER};
|
|
|
|
ReceptorCollection[0] = { 5, 0, BAS, 255, 0, 0, false }; // Receptor RED
|
|
ReceptorCollection[1] = { 12, 5, GAUCHE, 0, 255, 0, false }; // Receptor GREEN
|
|
ReceptorCollection[2] = { 0, 4, DROITE, 0, 0, 255, false }; // Receptor BLUE
|
|
ReceptorCollection[3] = { 6, 10, HAUT, 0, 0, 0, false }; // Receptor BLACK
|
|
// ReceptorCollection[4] = { 12, 3, GAUCHE, 255, 0, 255, false }; // Receptor PINK
|
|
// ReceptorCollection[5] = { 9, 10, HAUT, 0, 255, 255, false }; // Receptor CYAN
|
|
// ReceptorCollection[6] = { 12, 8, GAUCHE, 255, 255, 0, false }; // Receptor YELLOW
|
|
// ReceptorCollection[7] = { 0, 7, DROITE, 255, 255, 255, false }; // Receptor WHITE
|
|
|
|
MonstersCollection[0] = { 5, 3, 1, 5, HORIZONTAL, GAUCHE, GHOST };
|
|
MonstersCollection[1] = { 5, 2, 1, 5, HORIZONTAL, GAUCHE, GHOST };
|
|
MonstersCollection[2] = { 7, 3, 7, 11, HORIZONTAL, DROITE, GHOST };
|
|
MonstersCollection[3] = { 7, 2, 7, 11, HORIZONTAL, DROITE, GHOST };
|
|
MonstersCollection[4] = { 5, 7, 1, 5, HORIZONTAL, GAUCHE, GHOST };
|
|
MonstersCollection[5] = { 5, 8, 1, 5, HORIZONTAL, GAUCHE, GHOST };
|
|
MonstersCollection[6] = { 7, 7, 7, 11, HORIZONTAL, DROITE, GHOST };
|
|
MonstersCollection[7] = { 7, 8, 7, 11, HORIZONTAL, DROITE, GHOST };
|
|
}
|
|
else if (numLevel==11) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 0;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 4;
|
|
NbDoorsLevel = 2;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 4;
|
|
NbObstacleLevel = 24;
|
|
NbMonsterLevel = 4;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=-2;
|
|
Map[numLevel].y=-4;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=false;
|
|
Map[numLevel].doorNorth=true;
|
|
Map[numLevel].doorEast=false;
|
|
Map[numLevel].doorSouth=true;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
ReceptorCollection[0] = { 9, 1, BAS, 255, 0, 0, false }; // Receptor RED
|
|
ReceptorCollection[1] = { 4, 10, HAUT, 0, 255, 0, false }; // Receptor GREEN
|
|
ReceptorCollection[2] = { 3, 3, DROITE, 0, 0, 255, false }; // Receptor BLUE
|
|
ReceptorCollection[3] = { 5, 10, HAUT, 0, 0, 0, false }; // Receptor BLACK
|
|
// ReceptorCollection[4] = { 12, 3, GAUCHE, 255, 0, 255, false }; // Receptor PINK
|
|
// ReceptorCollection[5] = { 9, 10, HAUT, 0, 255, 255, false }; // Receptor CYAN
|
|
// ReceptorCollection[6] = { 12, 8, GAUCHE, 255, 255, 0, false }; // Receptor YELLOW
|
|
// ReceptorCollection[7] = { 0, 7, DROITE, 255, 255, 255, false }; // Receptor WHITE
|
|
|
|
|
|
DoorCollection[0] = { 6,0, HAUT, false, true, 3, { 0,1,2 },15}; // Door NORTH
|
|
//DoorCollection[1] = { 0, 5, GAUCHE, false, true, 0, { -1, -1, -1 }, 9}; // Door WEST
|
|
//DoorCollection[1] = { 12, 5, DROITE, false, true, 0, { -1, -1, -1 }, 10}; // Door EAST
|
|
DoorCollection[1] = { 6, 10, BAS, false, true, 1, { 3, -1, -1 }, 6}; // Door SOUTH
|
|
|
|
ObstaclesCollection[0] = {5,3,BLOCK_WATER};
|
|
ObstaclesCollection[1] = {5,5,BLOCK_WATER};
|
|
ObstaclesCollection[2] = {5,7,BLOCK_WATER};
|
|
ObstaclesCollection[3] = {6,6,BLOCK_WATER};
|
|
ObstaclesCollection[4] = {7,3,BLOCK_WATER};
|
|
ObstaclesCollection[5] = {7,5,BLOCK_WATER};
|
|
ObstaclesCollection[6] = {7,7,BLOCK_WATER};
|
|
ObstaclesCollection[7] = {6,4,BLOCK_WATER};
|
|
|
|
ObstaclesCollection[8] = {1,3,BLOCK_MOON};
|
|
ObstaclesCollection[9] = {3,3,BLOCK_MOON};
|
|
ObstaclesCollection[10] = {1,5,BLOCK_MOON};
|
|
ObstaclesCollection[11] = {3,5,BLOCK_MOON};
|
|
ObstaclesCollection[12] = {1,7,BLOCK_MOON};
|
|
ObstaclesCollection[13] = {3,7,BLOCK_MOON};
|
|
ObstaclesCollection[14] = {3,1,BLOCK_MOON};
|
|
ObstaclesCollection[15] = {3,9,BLOCK_MOON};
|
|
|
|
ObstaclesCollection[16] = {11,3,BLOCK_MOON};
|
|
ObstaclesCollection[17] = {9,3,BLOCK_MOON};
|
|
ObstaclesCollection[18] = {11,5,BLOCK_MOON};
|
|
ObstaclesCollection[19] = {9,5,BLOCK_MOON};
|
|
ObstaclesCollection[20] = {11,7,BLOCK_MOON};
|
|
ObstaclesCollection[21] = {9,7,BLOCK_MOON};
|
|
ObstaclesCollection[22] = {9,1,BLOCK_MOON};
|
|
ObstaclesCollection[23] = {9,9,BLOCK_MOON};
|
|
|
|
|
|
|
|
|
|
TreasureCollection[0] = {1,1, T_RED, false, HEART_SINGLE, 100, true };
|
|
TreasureCollection[1] = {11,1, T_YELLOW, false, HEART_SINGLE, 100, true };
|
|
TreasureCollection[2] = {11,9, T_GREEN, false, HEART_SINGLE, 100, true };
|
|
TreasureCollection[3] = {1,9, T_BLUE, false, HEART_SINGLE, 100, true };
|
|
|
|
MonstersCollection[0] = { 2, 1, 1, 9, VERTICAL, BAS, BAT };
|
|
MonstersCollection[1] = { 10, 1, 1, 9, VERTICAL, HAUT, BAT };
|
|
MonstersCollection[2] = { 1, 2, 1, 11, HORIZONTAL, DROITE, BAT };
|
|
MonstersCollection[3] = { 11, 8, 1, 11, HORIZONTAL, GAUCHE, BAT };
|
|
|
|
|
|
}
|
|
else if (numLevel==12) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 2;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 1;
|
|
NbDoorsLevel = 1;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 3;
|
|
NbObstacleLevel = 0;
|
|
NbMonsterLevel = 0;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=0;
|
|
Map[numLevel].y=-4;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=0;
|
|
Map[numLevel].B=0;
|
|
Map[numLevel].A=255;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=false;
|
|
Map[numLevel].doorNorth=false;
|
|
Map[numLevel].doorEast=false;
|
|
Map[numLevel].doorSouth=true;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
ReceptorCollection[0] = { 0, 5, DROITE, 255, 255, 255, false }; // Receptor WHITE
|
|
|
|
//DoorCollection[0] = { 6,0, HAUT, false, true, 0, { -1,-1, -1 },6}; // Door NORTH
|
|
//DoorCollection[1] = { 0, 5, GAUCHE, false, true, 0, { -1, -1, -1 }, 9}; // Door WEST
|
|
//DoorCollection[1] = { 12, 5, DROITE, false, true, 0, { -1, -1, -1 }, 10}; // Door EAST
|
|
DoorCollection[0] = { 6, 10, BAS, false, true, 1, { 0, -1, -1 }, 8}; // Door SOUTH
|
|
|
|
TreasureCollection[0] = {6,2, T_RED, false, RED_FRAGMENT, 1000, true };
|
|
TreasureCollection[1] = {1,2, T_YELLOW, false, HEART_SINGLE, 100, true };
|
|
TreasureCollection[2] = {11,2, T_YELLOW, false, HEART_SINGLE, 100, true };
|
|
//TreasureCollection[3] = {1,1, T_BLUE, true, PIERRE_BLANCHE, 100, true };
|
|
|
|
}
|
|
else if (numLevel==13) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 0;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 4;
|
|
NbDoorsLevel = 2;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 4;
|
|
NbObstacleLevel = 24;
|
|
NbMonsterLevel = 4;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=2;
|
|
Map[numLevel].y=-4;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=false;
|
|
Map[numLevel].doorNorth=true;
|
|
Map[numLevel].doorEast=false;
|
|
Map[numLevel].doorSouth=true;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
|
|
ReceptorCollection[0] = { 9, 1, BAS, 255, 0, 0, false }; // Receptor RED
|
|
ReceptorCollection[1] = { 4, 10, HAUT, 0, 255, 0, false }; // Receptor GREEN
|
|
ReceptorCollection[2] = { 3, 3, DROITE, 0, 0, 255, false }; // Receptor BLUE
|
|
ReceptorCollection[3] = { 5, 10, HAUT, 0, 0, 0, false }; // Receptor BLACK
|
|
// ReceptorCollection[4] = { 12, 3, GAUCHE, 255, 0, 255, false }; // Receptor PINK
|
|
// ReceptorCollection[5] = { 9, 10, HAUT, 0, 255, 255, false }; // Receptor CYAN
|
|
// ReceptorCollection[6] = { 12, 8, GAUCHE, 255, 255, 0, false }; // Receptor YELLOW
|
|
// ReceptorCollection[7] = { 0, 7, DROITE, 255, 255, 255, false }; // Receptor WHITE
|
|
|
|
DoorCollection[0] = { 6,0, HAUT, false, true, 3, { 0,1, 2 },19}; // Door NORTH
|
|
//DoorCollection[1] = { 0, 5, GAUCHE, false, true, 0, { -1, -1, -1 }, 9}; // Door WEST
|
|
//DoorCollection[1] = { 12, 5, DROITE, false, true, 0, { -1, -1, -1 }, 10}; // Door EAST
|
|
DoorCollection[1] = { 6, 10, BAS, false, true, 1, { 3, -1, -1 }, 10}; // Door SOUTH
|
|
|
|
ObstaclesCollection[0] = {5,3,BLOCK_WATER};
|
|
ObstaclesCollection[1] = {5,5,BLOCK_WATER};
|
|
ObstaclesCollection[2] = {5,7,BLOCK_WATER};
|
|
ObstaclesCollection[3] = {6,6,BLOCK_WATER};
|
|
ObstaclesCollection[4] = {7,3,BLOCK_WATER};
|
|
ObstaclesCollection[5] = {7,5,BLOCK_WATER};
|
|
ObstaclesCollection[6] = {7,7,BLOCK_WATER};
|
|
ObstaclesCollection[7] = {6,4,BLOCK_WATER};
|
|
|
|
ObstaclesCollection[8] = {1,3,BLOCK_SUN};
|
|
ObstaclesCollection[9] = {3,3,BLOCK_SUN};
|
|
ObstaclesCollection[10] = {1,5,BLOCK_SUN};
|
|
ObstaclesCollection[11] = {3,5,BLOCK_SUN};
|
|
ObstaclesCollection[12] = {1,7,BLOCK_SUN};
|
|
ObstaclesCollection[13] = {3,7,BLOCK_SUN};
|
|
ObstaclesCollection[14] = {3,1,BLOCK_SUN};
|
|
ObstaclesCollection[15] = {3,9,BLOCK_SUN};
|
|
|
|
ObstaclesCollection[16] = {11,3,BLOCK_SUN};
|
|
ObstaclesCollection[17] = {9,3,BLOCK_SUN};
|
|
ObstaclesCollection[18] = {11,5,BLOCK_SUN};
|
|
ObstaclesCollection[19] = {9,5,BLOCK_SUN};
|
|
ObstaclesCollection[20] = {11,7,BLOCK_SUN};
|
|
ObstaclesCollection[21] = {9,7,BLOCK_SUN};
|
|
ObstaclesCollection[22] = {9,1,BLOCK_SUN};
|
|
ObstaclesCollection[23] = {9,9,BLOCK_SUN};
|
|
|
|
TreasureCollection[0] = {1,1, T_RED, false, HEART_SINGLE, 100, true };
|
|
TreasureCollection[1] = {11,1, T_YELLOW, false, HEART_SINGLE, 100, true };
|
|
TreasureCollection[2] = {11,9, T_GREEN, false, HEART_SINGLE, 100, true };
|
|
TreasureCollection[3] = {1,9, T_BLUE, false, HEART_SINGLE, 100, true };
|
|
|
|
MonstersCollection[0] = { 2, 1, 1, 9, VERTICAL, BAS, GHOST };
|
|
MonstersCollection[1] = { 10, 9, 1, 9, VERTICAL, HAUT, BAT };
|
|
MonstersCollection[2] = { 1, 2, 1, 11, HORIZONTAL, DROITE, SKELETON };
|
|
MonstersCollection[3] = { 11, 8, 1, 11, HORIZONTAL, GAUCHE, SPIDER };
|
|
}
|
|
else if (numLevel==14) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 0;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 4;
|
|
NbDoorsLevel = 2;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 2;
|
|
NbObstacleLevel = 20;
|
|
NbMonsterLevel = 3;
|
|
NbBossLevel = 1;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=-3;
|
|
Map[numLevel].y=-5;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=false;
|
|
Map[numLevel].doorNorth=true;
|
|
Map[numLevel].doorEast=true;
|
|
Map[numLevel].doorSouth=false;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
DoorCollection[0] = { 6,0, HAUT, false, true, 3, { 0,1,2 }, 21}; // Door NORTH
|
|
//DoorCollection[1] = { 0, 5, GAUCHE, false, true, 0, { -1, -1, -1 }, 0}; // Door WEST
|
|
DoorCollection[1] = { 12, 5, DROITE, false, true, 1, { 3, -1, -1 }, 15}; // Door EAST
|
|
//DoorCollection[1] = { 6, 10, BAS, false, true, 0, { -1, -1, -1 }, 0}; // Door SOUTH
|
|
|
|
ReceptorCollection[0] = { 1, 0, BAS, 255, 0, 0, false }; // Receptor RED
|
|
ReceptorCollection[1] = { 11, 0, BAS, 0, 255, 0, false }; // Receptor GREEN
|
|
ReceptorCollection[2] = { 11, 10, HAUT, 0, 0, 255, false }; // Receptor BLUE
|
|
ReceptorCollection[3] = { 1, 10, HAUT, 0, 0, 0, false }; // Receptor BLACK
|
|
|
|
BossCollection[0] = { 6, 2, 2, 10, HORIZONTAL, GAUCHE, B_GREEN };
|
|
|
|
ObstaclesCollection[0] = {1,4,BLOCK_WATER};
|
|
ObstaclesCollection[1] = {1,6,BLOCK_WATER};
|
|
ObstaclesCollection[2] = {3,4,BLOCK_WATER};
|
|
ObstaclesCollection[3] = {3,6,BLOCK_WATER};
|
|
ObstaclesCollection[4] = {4,4,BLOCK_WATER};
|
|
ObstaclesCollection[5] = {4,6,BLOCK_WATER};
|
|
|
|
ObstaclesCollection[6] = {8,4,BLOCK_WATER};
|
|
ObstaclesCollection[7] = {8,6,BLOCK_WATER};
|
|
ObstaclesCollection[8] = {9,4,BLOCK_WATER};
|
|
ObstaclesCollection[9] = {9,6,BLOCK_WATER};
|
|
ObstaclesCollection[10] = {11,4,BLOCK_WATER};
|
|
ObstaclesCollection[11] = {11,6,BLOCK_WATER};
|
|
|
|
ObstaclesCollection[12] = {5,1,BLOCK_WATER};
|
|
ObstaclesCollection[13] = {7,1,BLOCK_WATER};
|
|
ObstaclesCollection[14] = {5,3,BLOCK_WATER};
|
|
ObstaclesCollection[15] = {7,3,BLOCK_WATER};
|
|
|
|
ObstaclesCollection[16] = {5,7,BLOCK_WATER};
|
|
ObstaclesCollection[17] = {7,7,BLOCK_WATER};
|
|
ObstaclesCollection[18] = {5,9,BLOCK_WATER};
|
|
ObstaclesCollection[19] = {7,9,BLOCK_WATER};
|
|
|
|
TreasureCollection[0] = {1,5, T_GREEN, false, HEART_FULL, 10000, true };
|
|
TreasureCollection[1] = {6,9, T_YELLOW, false, PIERRE_BLANCHE, 1000, true };
|
|
|
|
//MonstersCollection[0] = { 6, 2, 4, 8, HORIZONTAL, DROITE, SKELETON };
|
|
MonstersCollection[0] = { 6, 8, 4, 8, HORIZONTAL, DROITE, BLOB };
|
|
|
|
MonstersCollection[1] = { 2, 5, 3, 7, VERTICAL, HAUT, BAT };
|
|
MonstersCollection[2] = { 10, 5, 3, 7, VERTICAL, BAS, GHOST };
|
|
|
|
}
|
|
else if (numLevel==15) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 0;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 7;
|
|
NbDoorsLevel = 3;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 0;
|
|
NbObstacleLevel = 12;
|
|
NbMonsterLevel = 3;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=-2;
|
|
Map[numLevel].y=-5;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=true;
|
|
Map[numLevel].doorNorth=false;
|
|
Map[numLevel].doorEast=true;
|
|
Map[numLevel].doorSouth=true;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
//DoorCollection[0] = { 6,0, HAUT, false, true, 0, { -1,-1, -1 }, 11}; // Door NORTH
|
|
DoorCollection[0] = { 0, 5, GAUCHE, false, true, 3, { 4, 5, 6 }, 14}; // Door WEST
|
|
DoorCollection[1] = { 12, 5, DROITE, false, true, 3, { 0, 1, 2 }, 16}; // Door EAST
|
|
DoorCollection[2] = { 6, 10, BAS, false, true, 1, { 3, -1, -1 }, 11}; // Door SOUTH
|
|
|
|
ReceptorCollection[0] = { 10, 0, BAS, 0, 0, 255, false };
|
|
ReceptorCollection[1] = { 12, 2, GAUCHE, 255, 255, 0, false };
|
|
ReceptorCollection[2] = { 11, 0, BAS, 255, 0, 255, false };
|
|
|
|
ReceptorCollection[3] = { 1, 10, HAUT, 0, 0, 0, false };
|
|
|
|
ReceptorCollection[4] = { 0, 2, DROITE, 255, 0, 255, false };
|
|
ReceptorCollection[5] = { 1, 0, BAS, 0, 255, 255, false };
|
|
ReceptorCollection[6] = { 3, 0, BAS, 0, 255, 0, false };
|
|
|
|
|
|
ObstaclesCollection[0] = {6,2,BLOCK_WATER};
|
|
ObstaclesCollection[1] = {5,3,BLOCK_WATER};
|
|
ObstaclesCollection[2] = {7,3,BLOCK_WATER};
|
|
ObstaclesCollection[3] = {4,4,BLOCK_WATER};
|
|
ObstaclesCollection[4] = {8,4,BLOCK_WATER};
|
|
ObstaclesCollection[5] = {3,5,BLOCK_WATER};
|
|
ObstaclesCollection[6] = {9,5,BLOCK_WATER};
|
|
ObstaclesCollection[7] = {4,6,BLOCK_WATER};
|
|
ObstaclesCollection[8] = {8,6,BLOCK_WATER};
|
|
ObstaclesCollection[9] = {5,7,BLOCK_WATER};
|
|
ObstaclesCollection[10] = {7,7,BLOCK_WATER};
|
|
ObstaclesCollection[11] = {6,8,BLOCK_WATER};
|
|
|
|
MonstersCollection[0] = { 6, 1, 1, 11, HORIZONTAL, DROITE, GHOST };
|
|
MonstersCollection[1] = { 1, 5, 1, 9, VERTICAL, HAUT, GHOST };
|
|
MonstersCollection[2] = { 11, 5, 1, 9, VERTICAL, HAUT, GHOST };
|
|
|
|
}
|
|
else if (numLevel==16) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 1;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 9;
|
|
NbDoorsLevel = 3;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 4;
|
|
NbObstacleLevel = 8;
|
|
NbMonsterLevel = 4;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=-1;
|
|
Map[numLevel].y=-5;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=true;
|
|
Map[numLevel].doorNorth=true;
|
|
Map[numLevel].doorEast=true;
|
|
Map[numLevel].doorSouth=false;
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
ObstaclesCollection[0] = {2,2,BLOCK_SUN};
|
|
ObstaclesCollection[1] = {10,2,BLOCK_SUN};
|
|
ObstaclesCollection[2] = {2,8,BLOCK_SUN};
|
|
ObstaclesCollection[3] = {10,8,BLOCK_SUN};
|
|
ObstaclesCollection[4] = {4,5,BLOCK_WATER};
|
|
ObstaclesCollection[5] = {8,5,BLOCK_WATER};
|
|
ObstaclesCollection[6] = {6,3,BLOCK_WATER};
|
|
ObstaclesCollection[7] = {6,7,BLOCK_WATER};
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
ReceptorCollection[0] = { 2, 8, HAUT, 0, 255, 0, false };
|
|
ReceptorCollection[1] = { 9, 10, HAUT, 255, 0, 255, false };
|
|
ReceptorCollection[2] = { 12, 2, GAUCHE, 0, 0, 0, false };
|
|
|
|
ReceptorCollection[3] = { 10, 8, HAUT, 0, 0, 255, false };
|
|
ReceptorCollection[4] = { 5, 10, HAUT, 255, 0, 0, false };
|
|
ReceptorCollection[5] = { 8, 0, BAS, 0, 0, 0, false };
|
|
|
|
ReceptorCollection[6] = { 2, 10, HAUT, 255, 255, 0, false };
|
|
ReceptorCollection[7] = { 8, 10, HAUT, 255, 0, 255, false };
|
|
ReceptorCollection[8] = { 12, 7, GAUCHE, 0, 0, 255, false };
|
|
|
|
DoorCollection[0] = { 6,0, HAUT, false, true, 3, { 0,1, 2 }, 22}; // Door NORTH
|
|
DoorCollection[1] = { 0, 5, GAUCHE, false, true, 3, { 3, 4, 5 }, 15}; // Door WEST
|
|
DoorCollection[2] = { 12, 5, DROITE, false, true, 3, { 6, 7, 8 }, 18}; // Door EAST
|
|
//DoorCollection[3] = { 6, 10, BAS, false, false, 0, { -1 -1, -1 }, -1}; // Door SOUTH
|
|
|
|
TreasureCollection[0] = {4,4, T_RED, false, PIERRE_BLANCHE, 1000, true };
|
|
TreasureCollection[1] = {8,4, T_YELLOW, false, HEART_FULL, 1000, true };
|
|
TreasureCollection[2] = {4,6, T_GREEN, false, HEART_FULL, 1000, true };
|
|
TreasureCollection[3] = {8,6, T_BLUE, false, PIERRE_BLANCHE, 1000, true };
|
|
|
|
MonstersCollection[0] = { 6, 2, 1, 11, HORIZONTAL, DROITE, GHOST };
|
|
MonstersCollection[1] = { 6, 8, 1, 11, HORIZONTAL, GAUCHE, GHOST };
|
|
MonstersCollection[2] = { 2, 5, 1, 9, VERTICAL, HAUT, GHOST };
|
|
MonstersCollection[3] = { 10, 5, 1, 9, VERTICAL, BAS, GHOST };
|
|
|
|
}
|
|
else if (numLevel==17) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 0;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 0;
|
|
NbDoorsLevel = 3;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 1;
|
|
NbObstacleLevel = 20;
|
|
NbMonsterLevel = 4;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=-0;
|
|
Map[numLevel].y=-5;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=true;
|
|
Map[numLevel].doorNorth=true;
|
|
Map[numLevel].doorEast=true;
|
|
Map[numLevel].doorSouth=false;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 1, 1, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 11, 1, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 11, 9, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 1, 9, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
DoorCollection[0] = { 6,0, HAUT, false, true, 0, { -1,-1, -1 }, 23}; // Door NORTH
|
|
DoorCollection[1] = { 0, 5, GAUCHE, false, true, 0, { -1, -1, -1 }, 16}; // Door WEST
|
|
DoorCollection[2] = { 12, 5, DROITE, false, true, 0, { -1, -1, -1 }, 18}; // Door EAST
|
|
//DoorCollection[2] = { 6, 10, BAS, false, true, 0, { -1, -1, -1 }, 4}; // Door SOUTH
|
|
|
|
|
|
ObstaclesCollection[0] = {1,4,BLOCK_STONE};
|
|
ObstaclesCollection[1] = {1,6,BLOCK_STONE};
|
|
ObstaclesCollection[2] = {3,4,BLOCK_STONE};
|
|
ObstaclesCollection[3] = {3,6,BLOCK_STONE};
|
|
ObstaclesCollection[4] = {4,4,BLOCK_STONE};
|
|
ObstaclesCollection[5] = {4,6,BLOCK_STONE};
|
|
|
|
ObstaclesCollection[6] = {8,4,BLOCK_STONE};
|
|
ObstaclesCollection[7] = {8,6,BLOCK_STONE};
|
|
ObstaclesCollection[8] = {9,4,BLOCK_STONE};
|
|
ObstaclesCollection[9] = {9,6,BLOCK_STONE};
|
|
ObstaclesCollection[10] = {11,4,BLOCK_STONE};
|
|
ObstaclesCollection[11] = {11,6,BLOCK_STONE};
|
|
|
|
ObstaclesCollection[12] = {5,1,BLOCK_STONE};
|
|
ObstaclesCollection[13] = {7,1,BLOCK_STONE};
|
|
ObstaclesCollection[14] = {5,3,BLOCK_STONE};
|
|
ObstaclesCollection[15] = {7,3,BLOCK_STONE};
|
|
|
|
ObstaclesCollection[16] = {5,7,BLOCK_STONE};
|
|
ObstaclesCollection[17] = {7,7,BLOCK_STONE};
|
|
ObstaclesCollection[18] = {5,9,BLOCK_STONE};
|
|
ObstaclesCollection[19] = {7,9,BLOCK_STONE};
|
|
|
|
TreasureCollection[0] = {6,9, T_GREEN, false, HEART_FULL, 10000, true };
|
|
|
|
MonstersCollection[0] = { 6, 2, 4, 8, HORIZONTAL, DROITE, SKELETON };
|
|
MonstersCollection[1] = { 6, 8, 4, 8, HORIZONTAL, DROITE, BLOB };
|
|
|
|
MonstersCollection[2] = { 2, 5, 3, 7, VERTICAL, HAUT, BAT };
|
|
MonstersCollection[3] = { 10, 5, 3, 7, VERTICAL, BAS, GHOST };
|
|
|
|
|
|
}
|
|
else if (numLevel==18) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 2;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 9;
|
|
NbDoorsLevel = 3;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 4;
|
|
NbObstacleLevel = 8;
|
|
NbMonsterLevel = 4;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=1;
|
|
Map[numLevel].y=-5;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=true;
|
|
Map[numLevel].doorNorth=true;
|
|
Map[numLevel].doorEast=true;
|
|
Map[numLevel].doorSouth=false;
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
ObstaclesCollection[0] = {2,2,BLOCK_SUN};
|
|
ObstaclesCollection[1] = {10,2,BLOCK_SUN};
|
|
ObstaclesCollection[2] = {2,8,BLOCK_SUN};
|
|
ObstaclesCollection[3] = {10,8,BLOCK_SUN};
|
|
ObstaclesCollection[4] = {4,5,BLOCK_WATER};
|
|
ObstaclesCollection[5] = {8,5,BLOCK_WATER};
|
|
ObstaclesCollection[6] = {6,3,BLOCK_WATER};
|
|
ObstaclesCollection[7] = {6,7,BLOCK_WATER};
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
ReceptorCollection[0] = { 2, 8, HAUT, 0, 255, 0, false };
|
|
ReceptorCollection[1] = { 9, 10, HAUT, 255, 0, 255, false };
|
|
ReceptorCollection[2] = { 12, 2, GAUCHE, 0, 0, 0, false };
|
|
|
|
ReceptorCollection[3] = { 10, 8, HAUT, 0, 0, 255, false };
|
|
ReceptorCollection[4] = { 5, 10, HAUT, 255, 0, 0, false };
|
|
ReceptorCollection[5] = { 8, 0, BAS, 0, 0, 0, false };
|
|
|
|
ReceptorCollection[6] = { 2, 10, HAUT, 255, 255, 0, false };
|
|
ReceptorCollection[7] = { 8, 10, HAUT, 255, 0, 255, false };
|
|
ReceptorCollection[8] = { 12, 7, GAUCHE, 0, 0, 255, false };
|
|
|
|
DoorCollection[0] = { 6,0, HAUT, false, true, 3, { 0,1, 2 }, 24}; // Door NORTH
|
|
DoorCollection[1] = { 0, 5, GAUCHE, false, true, 3, { 3, 4, 5 }, 17}; // Door WEST
|
|
DoorCollection[2] = { 12, 5, DROITE, false, true, 3, { 6, 7, 8 }, 19}; // Door EAST
|
|
//DoorCollection[3] = { 6, 10, BAS, false, false, 0, { -1 -1, -1 }, -1}; // Door SOUTH
|
|
|
|
TreasureCollection[0] = {4,4, T_RED, false, PIERRE_BLANCHE, 1000, true };
|
|
TreasureCollection[1] = {8,4, T_YELLOW, false, HEART_FULL, 1000, true };
|
|
TreasureCollection[2] = {4,6, T_GREEN, false, HEART_FULL, 1000, true };
|
|
TreasureCollection[3] = {8,6, T_BLUE, false, PIERRE_BLANCHE, 1000, true };
|
|
|
|
MonstersCollection[0] = { 6, 2, 1, 11, HORIZONTAL, DROITE, BLOB };
|
|
MonstersCollection[1] = { 6, 8, 1, 11, HORIZONTAL, GAUCHE, BLOB };
|
|
MonstersCollection[2] = { 2, 5, 1, 9, VERTICAL, HAUT, BLOB };
|
|
MonstersCollection[3] = { 10, 5, 1, 9, VERTICAL, BAS, BLOB };
|
|
|
|
}
|
|
else if (numLevel==19) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 1;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 7;
|
|
NbDoorsLevel = 3;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 0;
|
|
NbObstacleLevel = 12;
|
|
NbMonsterLevel = 3;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=2;
|
|
Map[numLevel].y=-5;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=true;
|
|
Map[numLevel].doorNorth=false;
|
|
Map[numLevel].doorEast=true;
|
|
Map[numLevel].doorSouth=true;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
//DoorCollection[0] = { 6,0, HAUT, false, true, 0, { -1,-1, -1 },12}; // Door NORTH
|
|
DoorCollection[0] = { 0, 5, GAUCHE, false, true, 3, { 4, 5, 6 }, 18}; // Door WEST
|
|
DoorCollection[1] = { 12, 5, DROITE, false, true, 3, { 0, 1, 2 }, 20}; // Door EAST
|
|
DoorCollection[2] = { 6, 10, BAS, false, true, 1, { 3, -1, -1 }, 13}; // Door SOUTH
|
|
|
|
|
|
ReceptorCollection[0] = { 8, 0, BAS, 255, 0, 0, false };
|
|
ReceptorCollection[1] = { 9, 0, BAS, 255, 255, 0, false };
|
|
ReceptorCollection[2] = { 11, 0, BAS, 0, 255, 0, false };
|
|
|
|
ReceptorCollection[3] = { 1, 10, HAUT, 0, 0, 0, false };
|
|
|
|
ReceptorCollection[4] = { 0, 2, DROITE, 255, 0, 255, false };
|
|
ReceptorCollection[5] = { 1, 0, BAS, 0, 255, 255, false };
|
|
ReceptorCollection[6] = { 3, 0, BAS, 0, 255, 0, false };
|
|
|
|
|
|
ObstaclesCollection[0] = {6,2,BLOCK_WATER};
|
|
ObstaclesCollection[1] = {5,3,BLOCK_WATER};
|
|
ObstaclesCollection[2] = {7,3,BLOCK_WATER};
|
|
ObstaclesCollection[3] = {4,4,BLOCK_WATER};
|
|
ObstaclesCollection[4] = {8,4,BLOCK_WATER};
|
|
ObstaclesCollection[5] = {3,5,BLOCK_WATER};
|
|
ObstaclesCollection[6] = {9,5,BLOCK_WATER};
|
|
ObstaclesCollection[7] = {4,6,BLOCK_WATER};
|
|
ObstaclesCollection[8] = {8,6,BLOCK_WATER};
|
|
ObstaclesCollection[9] = {5,7,BLOCK_WATER};
|
|
ObstaclesCollection[10] = {7,7,BLOCK_WATER};
|
|
ObstaclesCollection[11] = {6,8,BLOCK_WATER};
|
|
|
|
MonstersCollection[0] = { 6, 1, 1, 11, HORIZONTAL, DROITE, SKELETON };
|
|
MonstersCollection[1] = { 1, 5, 1, 9, VERTICAL, HAUT, SKELETON };
|
|
MonstersCollection[2] = { 11, 5, 1, 9, VERTICAL, HAUT, SKELETON };
|
|
|
|
}
|
|
else if (numLevel==20) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 1;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 4;
|
|
NbDoorsLevel = 2;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 2;
|
|
NbObstacleLevel = 20;
|
|
NbMonsterLevel = 3;
|
|
NbBossLevel = 1;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=3;
|
|
Map[numLevel].y=-5;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=true;
|
|
Map[numLevel].doorNorth=true;
|
|
Map[numLevel].doorEast=false;
|
|
Map[numLevel].doorSouth=false;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
DoorCollection[0] = { 6,0, HAUT, false, true, 3, { 0,1,2 },25}; // Door NORTH
|
|
DoorCollection[1] = { 0, 5, GAUCHE, false, true, 1, { 3, -1, -1 }, 19}; // Door WEST
|
|
//DoorCollection[1] = { 12, 5, DROITE, false, true, 0, { -1, -1, -1 }, 10}; // Door EAST
|
|
//DoorCollection[2] = { 6, 10, BAS, false, true, 0, { -1, -1, -1 }, 5}; // Door SOUTH
|
|
|
|
|
|
ReceptorCollection[0] = { 1, 0, BAS, 255, 0, 0, false }; // Receptor RED
|
|
ReceptorCollection[1] = { 11, 0, BAS, 0, 255, 0, false }; // Receptor GREEN
|
|
ReceptorCollection[2] = { 11, 10, HAUT, 0, 0, 255, false }; // Receptor BLUE
|
|
ReceptorCollection[3] = { 1, 10, HAUT, 0, 0, 0, false }; // Receptor BLACK
|
|
|
|
BossCollection[0] = { 6, 2, 2, 10, HORIZONTAL, GAUCHE, B_BLUE };
|
|
|
|
ObstaclesCollection[0] = {1,4,BLOCK_WATER};
|
|
ObstaclesCollection[1] = {1,6,BLOCK_WATER};
|
|
ObstaclesCollection[2] = {3,4,BLOCK_WATER};
|
|
ObstaclesCollection[3] = {3,6,BLOCK_WATER};
|
|
ObstaclesCollection[4] = {4,4,BLOCK_WATER};
|
|
ObstaclesCollection[5] = {4,6,BLOCK_WATER};
|
|
|
|
ObstaclesCollection[6] = {8,4,BLOCK_WATER};
|
|
ObstaclesCollection[7] = {8,6,BLOCK_WATER};
|
|
ObstaclesCollection[8] = {9,4,BLOCK_WATER};
|
|
ObstaclesCollection[9] = {9,6,BLOCK_WATER};
|
|
ObstaclesCollection[10] = {11,4,BLOCK_WATER};
|
|
ObstaclesCollection[11] = {11,6,BLOCK_WATER};
|
|
|
|
ObstaclesCollection[12] = {5,1,BLOCK_WATER};
|
|
ObstaclesCollection[13] = {7,1,BLOCK_WATER};
|
|
ObstaclesCollection[14] = {5,3,BLOCK_WATER};
|
|
ObstaclesCollection[15] = {7,3,BLOCK_WATER};
|
|
|
|
ObstaclesCollection[16] = {5,7,BLOCK_WATER};
|
|
ObstaclesCollection[17] = {7,7,BLOCK_WATER};
|
|
ObstaclesCollection[18] = {5,9,BLOCK_WATER};
|
|
ObstaclesCollection[19] = {7,9,BLOCK_WATER};
|
|
|
|
TreasureCollection[0] = {11,5, T_BLUE, false, HEART_FULL, 10000, true };
|
|
TreasureCollection[1] = {6,9, T_YELLOW, false, PIERRE_BLANCHE, 1000, true };
|
|
|
|
//MonstersCollection[0] = { 6, 2, 4, 8, HORIZONTAL, DROITE, SKELETON };
|
|
MonstersCollection[0] = { 6, 8, 4, 8, HORIZONTAL, DROITE, SPIDER };
|
|
|
|
MonstersCollection[1] = { 2, 5, 3, 7, VERTICAL, HAUT, SKELETON };
|
|
MonstersCollection[2] = { 10, 5, 3, 7, VERTICAL, BAS, GHOST };
|
|
}
|
|
else if (numLevel==21) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 0;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 1;
|
|
NbDoorsLevel = 1;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 3;
|
|
NbObstacleLevel = 0;
|
|
NbMonsterLevel = 0;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=-3;
|
|
Map[numLevel].y=-6;
|
|
Map[numLevel].R=0;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=0;
|
|
Map[numLevel].A=255;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=false;
|
|
Map[numLevel].doorNorth=false;
|
|
Map[numLevel].doorEast=false;
|
|
Map[numLevel].doorSouth=true;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
ReceptorCollection[0] = { 0, 5, DROITE, 255, 255, 255, false }; // Receptor WHITE
|
|
|
|
//DoorCollection[0] = { 6,0, HAUT, false, true, 0, { -1,-1, -1 },6}; // Door NORTH
|
|
//DoorCollection[1] = { 0, 5, GAUCHE, false, true, 0, { -1, -1, -1 }, 9}; // Door WEST
|
|
//DoorCollection[1] = { 12, 5, DROITE, false, true, 0, { -1, -1, -1 }, 10}; // Door EAST
|
|
DoorCollection[0] = { 6, 10, BAS, false, true, 1, { 0, -1, -1 }, 14}; // Door SOUTH
|
|
|
|
TreasureCollection[0] = {6,2, T_GREEN, false, GREEN_FRAGMENT, 1000, true };
|
|
TreasureCollection[1] = {1,2, T_YELLOW, false, HEART_SINGLE, 100, true };
|
|
TreasureCollection[2] = {11,2, T_YELLOW, false, HEART_SINGLE, 100, true };
|
|
//TreasureCollection[3] = {1,1, T_BLUE, true, PIERRE_BLANCHE, 100, true };
|
|
}
|
|
else if (numLevel==22) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 0;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 6;
|
|
NbDoorsLevel = 2;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 0;
|
|
NbObstacleLevel = 16;
|
|
NbMonsterLevel = 0;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=-1;
|
|
Map[numLevel].y=-6;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=false;
|
|
Map[numLevel].doorNorth=false;
|
|
Map[numLevel].doorEast=false;
|
|
Map[numLevel].doorSouth=true;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
DoorCollection[0] = { 6,0, HAUT, false, true, 3, { 0,1,2 },27}; // Door NORTH
|
|
//DoorCollection[1] = { 0, 5, GAUCHE, false, true, 0, { -1, -1, -1 }, 9}; // Door WEST
|
|
//DoorCollection[1] = { 12, 5, DROITE, false, true, 0, { -1, -1, -1 }, 10}; // Door EAST
|
|
DoorCollection[1] = { 6, 10, BAS, false, true, 3, { 3,4,5 }, 16}; // Door SOUTH
|
|
|
|
ReceptorCollection[0] = { 2, 6, DROITE, 0, 255, 255, false };
|
|
ReceptorCollection[1] = { 2, 2, DROITE, 0, 0, 255, false };
|
|
ReceptorCollection[2] = { 5, 2, BAS, 0, 0, 0, false };
|
|
ReceptorCollection[3] = { 7, 2, BAS, 0, 0, 0, false };
|
|
ReceptorCollection[4] = { 10, 2, GAUCHE, 0, 0, 255, false };
|
|
ReceptorCollection[5] = { 10, 6, GAUCHE, 255, 0, 255, false };
|
|
|
|
ObstaclesCollection[0] = {2,2,BLOCK_SUN};
|
|
ObstaclesCollection[1] = {5,2,BLOCK_SUN};
|
|
ObstaclesCollection[2] = {7,2,BLOCK_SUN};
|
|
ObstaclesCollection[3] = {10,2,BLOCK_SUN};
|
|
|
|
ObstaclesCollection[4] = {2,4,BLOCK_SUN};
|
|
ObstaclesCollection[5] = {5,4,BLOCK_WATER};
|
|
ObstaclesCollection[6] = {7,4,BLOCK_WATER};
|
|
ObstaclesCollection[7] = {10,4,BLOCK_SUN};
|
|
|
|
ObstaclesCollection[8] = {2,6,BLOCK_SUN};
|
|
ObstaclesCollection[9] = {5,6,BLOCK_WATER};
|
|
ObstaclesCollection[10] = {7,6,BLOCK_WATER};
|
|
ObstaclesCollection[11] = {10,6,BLOCK_SUN};
|
|
|
|
ObstaclesCollection[12] = {2,8,BLOCK_SUN};
|
|
ObstaclesCollection[13] = {5,8,BLOCK_SUN};
|
|
ObstaclesCollection[14] = {7,8,BLOCK_SUN};
|
|
ObstaclesCollection[15] = {10,8,BLOCK_SUN};
|
|
}
|
|
else if (numLevel==23) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 0;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 6;
|
|
NbDoorsLevel = 2;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 5;
|
|
NbObstacleLevel = 7;
|
|
NbMonsterLevel = 0;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=-0;
|
|
Map[numLevel].y=-6;
|
|
Map[numLevel].R=0;
|
|
Map[numLevel].G=0;
|
|
Map[numLevel].B=0;
|
|
Map[numLevel].A=255;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=false;
|
|
Map[numLevel].doorNorth=false;
|
|
Map[numLevel].doorEast=false;
|
|
Map[numLevel].doorSouth=true;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 4, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
ReceptorCollection[0] = { 2, 10, HAUT, 0, 0, 255, false }; // Receptor WHITE
|
|
ReceptorCollection[1] = { 3, 10, HAUT, 0, 255, 255, false }; // Receptor WHITE
|
|
ReceptorCollection[2] = { 5, 7, HAUT, 0, 0, 255, false }; // Receptor WHITE
|
|
ReceptorCollection[3] = { 7, 7, HAUT, 255, 0, 0, false }; // Receptor WHITE
|
|
ReceptorCollection[4] = { 9, 10, HAUT, 0, 0, 0, false }; // Receptor WHITE
|
|
ReceptorCollection[5] = { 10, 10, HAUT, 255, 0, 0, false }; // Receptor WHITE
|
|
|
|
|
|
ObstaclesCollection[0] = {5,9,BLOCK_STONE};
|
|
ObstaclesCollection[1] = {5,8,BLOCK_WATER};
|
|
ObstaclesCollection[2] = {5,7,BLOCK_STONE};
|
|
ObstaclesCollection[3] = {6,7,BLOCK_WATER};
|
|
ObstaclesCollection[4] = {7,7,BLOCK_STONE};
|
|
ObstaclesCollection[5] = {7,8,BLOCK_WATER};
|
|
ObstaclesCollection[6] = {7,9,BLOCK_STONE};
|
|
|
|
DoorCollection[0] = { 6,0, HAUT, false, true, 3, { 0, 1, 5 }, 28}; // Door NORTH
|
|
//DoorCollection[1] = { 0, 5, GAUCHE, false, true, 0, { -1, -1, -1 }, 9}; // Door WEST
|
|
//DoorCollection[1] = { 12, 5, DROITE, false, true, 0, { -1, -1, -1 }, 10}; // Door EAST
|
|
DoorCollection[1] = { 6, 10, BAS, false, true, 2, { 2, 3, -1 }, 17}; // Door SOUTH
|
|
|
|
TreasureCollection[0] = {6,6, T_GREEN, false, BLACK_FRAGMENT, 1000, true };
|
|
TreasureCollection[1] = {4,6, T_YELLOW, false, HEART_SINGLE, 100, true };
|
|
TreasureCollection[2] = {8,6, T_YELLOW, false, HEART_SINGLE, 100, true };
|
|
TreasureCollection[3] = {2,6, T_BLUE, false, PIERRE_BLANCHE, 1000, true };
|
|
TreasureCollection[4] = {10,6, T_BLUE, false, PIERRE_BLANCHE, 1000, true };
|
|
|
|
}
|
|
else if (numLevel==24) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 0;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 6;
|
|
NbDoorsLevel = 2;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 0;
|
|
NbObstacleLevel = 16;
|
|
NbMonsterLevel = 0;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=1;
|
|
Map[numLevel].y=-6;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=false;
|
|
Map[numLevel].doorNorth=false;
|
|
Map[numLevel].doorEast=false;
|
|
Map[numLevel].doorSouth=true;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
DoorCollection[0] = { 6,0, HAUT, false, true, 3, { 0,1,2 },29}; // Door NORTH
|
|
//DoorCollection[1] = { 0, 5, GAUCHE, false, true, 0, { -1, -1, -1 }, 9}; // Door WEST
|
|
//DoorCollection[1] = { 12, 5, DROITE, false, true, 0, { -1, -1, -1 }, 10}; // Door EAST
|
|
DoorCollection[1] = { 6, 10, BAS, false, true, 3, { 3,4,5 }, 18}; // Door SOUTH
|
|
|
|
ReceptorCollection[0] = { 2, 6, DROITE, 255, 255, 0, false };
|
|
ReceptorCollection[1] = { 2, 2, DROITE, 255, 0, 0, false };
|
|
ReceptorCollection[2] = { 5, 2, BAS, 255, 0, 255, false };
|
|
ReceptorCollection[3] = { 7, 2, BAS, 255, 0, 255, false };
|
|
ReceptorCollection[4] = { 10, 2, GAUCHE, 255, 0, 0, false };
|
|
ReceptorCollection[5] = { 10, 6, GAUCHE, 0, 0, 0, false };
|
|
|
|
ObstaclesCollection[0] = {2,2,BLOCK_SUN};
|
|
ObstaclesCollection[1] = {5,2,BLOCK_SUN};
|
|
ObstaclesCollection[2] = {7,2,BLOCK_SUN};
|
|
ObstaclesCollection[3] = {10,2,BLOCK_SUN};
|
|
|
|
ObstaclesCollection[4] = {2,4,BLOCK_SUN};
|
|
ObstaclesCollection[5] = {5,4,BLOCK_WATER};
|
|
ObstaclesCollection[6] = {7,4,BLOCK_WATER};
|
|
ObstaclesCollection[7] = {10,4,BLOCK_SUN};
|
|
|
|
ObstaclesCollection[8] = {2,6,BLOCK_SUN};
|
|
ObstaclesCollection[9] = {5,6,BLOCK_WATER};
|
|
ObstaclesCollection[10] = {7,6,BLOCK_WATER};
|
|
ObstaclesCollection[11] = {10,6,BLOCK_SUN};
|
|
|
|
ObstaclesCollection[12] = {2,8,BLOCK_SUN};
|
|
ObstaclesCollection[13] = {5,8,BLOCK_SUN};
|
|
ObstaclesCollection[14] = {7,8,BLOCK_SUN};
|
|
ObstaclesCollection[15] = {10,8,BLOCK_SUN};
|
|
}
|
|
else if (numLevel==25) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 2;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 1;
|
|
NbDoorsLevel = 1;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 3;
|
|
NbObstacleLevel = 0;
|
|
NbMonsterLevel = 0;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=3;
|
|
Map[numLevel].y=-6;
|
|
Map[numLevel].R=0;
|
|
Map[numLevel].G=0;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=255;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=false;
|
|
Map[numLevel].doorNorth=false;
|
|
Map[numLevel].doorEast=false;
|
|
Map[numLevel].doorSouth=true;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
ReceptorCollection[0] = { 0, 5, DROITE, 255, 255, 255, false }; // Receptor WHITE
|
|
|
|
//DoorCollection[0] = { 6,0, HAUT, false, true, 0, { -1,-1, -1 },6}; // Door NORTH
|
|
//DoorCollection[1] = { 0, 5, GAUCHE, false, true, 0, { -1, -1, -1 }, 9}; // Door WEST
|
|
//DoorCollection[1] = { 12, 5, DROITE, false, true, 0, { -1, -1, -1 }, 10}; // Door EAST
|
|
DoorCollection[0] = { 6, 10, BAS, false, true, 1, { 0, -1, -1 }, 20}; // Door SOUTH
|
|
|
|
TreasureCollection[0] = {6,2, T_BLUE, false, BLUE_FRAGMENT, 1000, true };
|
|
TreasureCollection[1] = {1,2, T_YELLOW, false, HEART_SINGLE, 100, true };
|
|
TreasureCollection[2] = {11,2, T_YELLOW, false, HEART_SINGLE, 100, true };
|
|
//TreasureCollection[3] = {1,1, T_BLUE, true, PIERRE_BLANCHE, 100, true };
|
|
}
|
|
else if (numLevel==26) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 1;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 3;
|
|
NbDoorsLevel = 1;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 4;
|
|
NbObstacleLevel = 12;
|
|
NbMonsterLevel = 0;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=-2;
|
|
Map[numLevel].y=-7;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=false;
|
|
Map[numLevel].doorNorth=false;
|
|
Map[numLevel].doorEast=true;
|
|
Map[numLevel].doorSouth=false;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
//DoorCollection[0] = { 6,0, HAUT, false, true, 0, { -1,-1, -1 },6}; // Door NORTH
|
|
//DoorCollection[1] = { 0, 5, GAUCHE, false, true, 0, { -1, -1, -1 }, 9}; // Door WEST
|
|
DoorCollection[0] = { 12, 5, DROITE, false, true, 3, { 0, 1, 2 }, 27}; // Door EAST
|
|
//DoorCollection[0] = { 6, 10, BAS, false, true, 0, { -1, -1, -1 }, 14}; // Door SOUTH
|
|
|
|
ReceptorCollection[0] = { 0, 5, DROITE, 255, 255, 255, false };
|
|
ReceptorCollection[1] = { 2, 1, BAS, 0, 255, 255, false };
|
|
ReceptorCollection[2] = { 2, 9, DROITE, 0, 0, 0, false };
|
|
|
|
TreasureCollection[0] = {2, 2, T_BLUE, false, HEART_SINGLE, 100, true };
|
|
TreasureCollection[1] = {10,2, T_BLUE, false, HEART_SINGLE, 100, true };
|
|
TreasureCollection[2] = {2, 8, T_BLUE, false, HEART_SINGLE, 100, true };
|
|
TreasureCollection[3] = {10,8, T_BLUE, false, HEART_SINGLE, 100, true };
|
|
|
|
ObstaclesCollection[0] = {1,1,BLOCK_STONE};
|
|
ObstaclesCollection[1] = {2,1,BLOCK_STONE};
|
|
ObstaclesCollection[2] = {1,2,BLOCK_STONE};
|
|
|
|
ObstaclesCollection[3] = {11,1,BLOCK_STONE};
|
|
ObstaclesCollection[4] = {10,1,BLOCK_STONE};
|
|
ObstaclesCollection[5] = {11,2,BLOCK_STONE};
|
|
|
|
ObstaclesCollection[6] = {1,9,BLOCK_STONE};
|
|
ObstaclesCollection[7] = {2,9,BLOCK_STONE};
|
|
ObstaclesCollection[8] = {1,8,BLOCK_STONE};
|
|
|
|
ObstaclesCollection[9] = {11,9,BLOCK_STONE};
|
|
ObstaclesCollection[10] = {10,9,BLOCK_STONE};
|
|
ObstaclesCollection[11] = {11,8,BLOCK_STONE};
|
|
|
|
}
|
|
else if (numLevel==27) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 0;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 7;
|
|
NbDoorsLevel = 3;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 0;
|
|
NbObstacleLevel = 12;
|
|
NbMonsterLevel = 3;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=-1;
|
|
Map[numLevel].y=-7;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=true;
|
|
Map[numLevel].doorNorth=false;
|
|
Map[numLevel].doorEast=true;
|
|
Map[numLevel].doorSouth=true;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
//DoorCollection[0] = { 6,0, HAUT, false, true, 0, { -1,-1, -1 }, 11}; // Door NORTH
|
|
DoorCollection[0] = { 0, 5, GAUCHE, false, true, 3, { 4, 5, 6 }, 26}; // Door WEST
|
|
DoorCollection[1] = { 12, 5, DROITE, false, true, 3, { 0, 1, 2 }, 28}; // Door EAST
|
|
DoorCollection[2] = { 6, 10, BAS, false, true, 1, { 3, -1, -1 }, 22}; // Door SOUTH
|
|
|
|
|
|
|
|
ReceptorCollection[0] = { 10, 0, BAS, 0, 0, 255, false };
|
|
ReceptorCollection[1] = { 12, 2, GAUCHE, 255, 255, 0, false };
|
|
ReceptorCollection[2] = { 11, 0, BAS, 255, 0, 255, false };
|
|
|
|
ReceptorCollection[3] = { 1, 10, HAUT, 0, 0, 0, false };
|
|
|
|
ReceptorCollection[4] = { 0, 2, DROITE, 255, 0, 255, false };
|
|
ReceptorCollection[5] = { 1, 0, BAS, 0, 255, 255, false };
|
|
ReceptorCollection[6] = { 3, 0, BAS, 0, 255, 0, false };
|
|
|
|
|
|
ObstaclesCollection[0] = {6,2,BLOCK_WATER};
|
|
ObstaclesCollection[1] = {5,3,BLOCK_WATER};
|
|
ObstaclesCollection[2] = {7,3,BLOCK_WATER};
|
|
ObstaclesCollection[3] = {4,4,BLOCK_WATER};
|
|
ObstaclesCollection[4] = {8,4,BLOCK_WATER};
|
|
ObstaclesCollection[5] = {3,5,BLOCK_WATER};
|
|
ObstaclesCollection[6] = {9,5,BLOCK_WATER};
|
|
ObstaclesCollection[7] = {4,6,BLOCK_WATER};
|
|
ObstaclesCollection[8] = {8,6,BLOCK_WATER};
|
|
ObstaclesCollection[9] = {5,7,BLOCK_WATER};
|
|
ObstaclesCollection[10] = {7,7,BLOCK_WATER};
|
|
ObstaclesCollection[11] = {6,8,BLOCK_WATER};
|
|
|
|
MonstersCollection[0] = { 6, 1, 1, 11, HORIZONTAL, DROITE, GHOST };
|
|
MonstersCollection[1] = { 1, 5, 1, 9, VERTICAL, HAUT, GHOST };
|
|
MonstersCollection[2] = { 11, 5, 1, 9, VERTICAL, HAUT, GHOST };
|
|
|
|
}
|
|
else if (numLevel==28) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 1;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 12;
|
|
NbDoorsLevel = 4;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 0;
|
|
NbObstacleLevel = 0;
|
|
NbMonsterLevel = 4;
|
|
NbBossLevel = 1;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=0;
|
|
Map[numLevel].y=-7;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=true;
|
|
Map[numLevel].doorNorth=true;
|
|
Map[numLevel].doorEast=true;
|
|
Map[numLevel].doorSouth=true;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 6, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
DoorCollection[0] = { 6,0, HAUT, false, true, 3, { 0,7,2 },31}; // Door NORTH
|
|
DoorCollection[1] = { 0, 5, GAUCHE, false, true, 3, { 10, 1, 4 }, 27}; // Door WEST
|
|
DoorCollection[2] = { 12, 5, DROITE, false, true, 3, { 6, 9, 11 }, 29}; // Door EAST
|
|
DoorCollection[3] = { 6, 10, BAS, false, true, 3, { 8, 3, 5 }, 23}; // Door SOUTH
|
|
|
|
|
|
BossCollection[0] = { 6, 5, 2, 10, HORIZONTAL, GAUCHE, B_BLACK };
|
|
|
|
MonstersCollection[0] = { 3, 5, 1, 9, VERTICAL, HAUT, SKELETON };
|
|
MonstersCollection[1] = { 5, 5, 1, 9, VERTICAL, BAS, SKELETON };
|
|
MonstersCollection[2] = { 7, 5, 1, 9, VERTICAL, BAS, SKELETON };
|
|
MonstersCollection[3] = { 9, 5, 1, 9, VERTICAL, HAUT, SKELETON };
|
|
|
|
ReceptorCollection[0] = { 1, 0, BAS, 255, 255, 0, false };
|
|
ReceptorCollection[1] = { 0, 6, DROITE, 255, 255, 0, false };
|
|
ReceptorCollection[2] = { 0, 7, DROITE, 255, 255, 255, false };
|
|
ReceptorCollection[3] = { 0, 9, DROITE, 255, 255, 255, false };
|
|
ReceptorCollection[4] = { 2, 10, HAUT, 255, 0, 255, false };
|
|
ReceptorCollection[5] = { 4, 10, HAUT, 255, 0, 255, false };
|
|
ReceptorCollection[6] = { 12, 1, GAUCHE, 255, 0, 0, false };
|
|
ReceptorCollection[7] = { 5, 0, BAS, 0, 0, 0, false };
|
|
ReceptorCollection[8] = { 2, 0, BAS, 255, 0, 0, false };
|
|
ReceptorCollection[9] = { 7, 0, BAS, 0, 0, 0, false };
|
|
ReceptorCollection[10] = { 11, 0, BAS, 255, 0, 0, false };
|
|
ReceptorCollection[11] = { 12, 7, GAUCHE, 255, 0, 0, false };
|
|
|
|
}
|
|
else if (numLevel==29) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 1;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 7;
|
|
NbDoorsLevel = 3;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 0;
|
|
NbObstacleLevel = 12;
|
|
NbMonsterLevel = 3;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=1;
|
|
Map[numLevel].y=-7;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=true;
|
|
Map[numLevel].doorNorth=false;
|
|
Map[numLevel].doorEast=true;
|
|
Map[numLevel].doorSouth=true;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
//DoorCollection[0] = { 6,0, HAUT, false, true, 0, { -1,-1, -1 },12}; // Door NORTH
|
|
DoorCollection[0] = { 0, 5, GAUCHE, false, true, 3, { 4, 5, 6 }, 28}; // Door WEST
|
|
DoorCollection[1] = { 12, 5, DROITE, false, true, 3, { 0, 1, 2 }, 30}; // Door EAST
|
|
DoorCollection[2] = { 6, 10, BAS, false, true, 1, { 3, -1, -1 }, 24}; // Door SOUTH
|
|
|
|
|
|
ReceptorCollection[0] = { 8, 0, BAS, 255, 0, 0, false };
|
|
ReceptorCollection[1] = { 9, 0, BAS, 255, 255, 0, false };
|
|
ReceptorCollection[2] = { 11, 0, BAS, 0, 255, 0, false };
|
|
|
|
ReceptorCollection[3] = { 1, 10, HAUT, 0, 0, 0, false };
|
|
|
|
ReceptorCollection[4] = { 0, 2, DROITE, 255, 0, 255, false };
|
|
ReceptorCollection[5] = { 1, 0, BAS, 0, 255, 255, false };
|
|
ReceptorCollection[6] = { 3, 0, BAS, 0, 255, 0, false };
|
|
|
|
|
|
ObstaclesCollection[0] = {6,2,BLOCK_WATER};
|
|
ObstaclesCollection[1] = {5,3,BLOCK_WATER};
|
|
ObstaclesCollection[2] = {7,3,BLOCK_WATER};
|
|
ObstaclesCollection[3] = {4,4,BLOCK_WATER};
|
|
ObstaclesCollection[4] = {8,4,BLOCK_WATER};
|
|
ObstaclesCollection[5] = {3,5,BLOCK_WATER};
|
|
ObstaclesCollection[6] = {9,5,BLOCK_WATER};
|
|
ObstaclesCollection[7] = {4,6,BLOCK_WATER};
|
|
ObstaclesCollection[8] = {8,6,BLOCK_WATER};
|
|
ObstaclesCollection[9] = {5,7,BLOCK_WATER};
|
|
ObstaclesCollection[10] = {7,7,BLOCK_WATER};
|
|
ObstaclesCollection[11] = {6,8,BLOCK_WATER};
|
|
|
|
MonstersCollection[0] = { 6, 1, 1, 11, HORIZONTAL, DROITE, SKELETON };
|
|
MonstersCollection[1] = { 1, 5, 1, 9, VERTICAL, HAUT, SKELETON };
|
|
MonstersCollection[2] = { 11, 5, 1, 9, VERTICAL, HAUT, SKELETON };
|
|
|
|
}
|
|
else if (numLevel==30) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 0;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 3;
|
|
NbDoorsLevel = 1;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 4;
|
|
NbObstacleLevel = 12;
|
|
NbMonsterLevel = 0;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=2;
|
|
Map[numLevel].y=-7;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=true;
|
|
Map[numLevel].doorNorth=false;
|
|
Map[numLevel].doorEast=false;
|
|
Map[numLevel].doorSouth=false;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 5, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
//DoorCollection[0] = { 6,0, HAUT, false, true, 0, { -1,-1, -1 },12}; // Door NORTH
|
|
DoorCollection[0] = { 0, 5, GAUCHE, false, true, 3, { 0, 1, 2 }, 29}; // Door WEST
|
|
//DoorCollection[1] = { 12, 5, DROITE, false, true, 0, { -1, -1, -1 }, 30}; // Door EAST
|
|
//DoorCollection[2] = { 6, 10, BAS, false, true, 0, { -1, -1, -1 }, 24}; // Door SOUTH
|
|
|
|
ReceptorCollection[0] = { 12, 5, GAUCHE, 255, 255, 255, false };
|
|
ReceptorCollection[1] = { 10, 1, BAS, 255, 0, 255, false };
|
|
ReceptorCollection[2] = { 2, 9, DROITE, 0, 0, 0, false };
|
|
|
|
TreasureCollection[0] = {2, 2, T_BLUE, false, HEART_SINGLE, 100, true };
|
|
TreasureCollection[1] = {10,2, T_BLUE, false, HEART_SINGLE, 100, true };
|
|
TreasureCollection[2] = {2, 8, T_BLUE, false, HEART_SINGLE, 100, true };
|
|
TreasureCollection[3] = {10,8, T_BLUE, false, HEART_SINGLE, 100, true };
|
|
|
|
ObstaclesCollection[0] = {1,1,BLOCK_STONE};
|
|
ObstaclesCollection[1] = {2,1,BLOCK_STONE};
|
|
ObstaclesCollection[2] = {1,2,BLOCK_STONE};
|
|
|
|
ObstaclesCollection[3] = {11,1,BLOCK_STONE};
|
|
ObstaclesCollection[4] = {10,1,BLOCK_STONE};
|
|
ObstaclesCollection[5] = {11,2,BLOCK_STONE};
|
|
|
|
ObstaclesCollection[6] = {1,9,BLOCK_STONE};
|
|
ObstaclesCollection[7] = {2,9,BLOCK_STONE};
|
|
ObstaclesCollection[8] = {1,8,BLOCK_STONE};
|
|
|
|
ObstaclesCollection[9] = {11,9,BLOCK_STONE};
|
|
ObstaclesCollection[10] = {10,9,BLOCK_STONE};
|
|
ObstaclesCollection[11] = {11,8,BLOCK_STONE};
|
|
}
|
|
else if (numLevel==31) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 0;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 5;
|
|
NbDoorsLevel = 2;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 4;
|
|
NbObstacleLevel = 13;
|
|
NbMonsterLevel = 0;
|
|
NbBossLevel = 1;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=-0;
|
|
Map[numLevel].y=-8;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=0;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=false;
|
|
Map[numLevel].doorNorth=true;
|
|
Map[numLevel].doorEast=false;
|
|
Map[numLevel].doorSouth=true;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 6, 7, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 8, 3, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 4, 7, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 4, 3, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 8, 7, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
DoorCollection[0] = { 6,0, HAUT, false, true, 3, { 2,3,4 },32}; // Door NORTH
|
|
//DoorCollection[1] = { 0, 5, GAUCHE, false, true, 0, { -1, -1, -1 }, 9}; // Door WEST
|
|
//DoorCollection[1] = { 12, 5, DROITE, false, true, 0, { -1, -1, -1 }, 10}; // Door EAST
|
|
DoorCollection[1] = { 6, 10, BAS, false, true, 2, { 0,1, -1 }, 28}; // Door SOUTH
|
|
|
|
|
|
ReceptorCollection[0] = { 1, 1, DROITE, 255, 0, 0, false };
|
|
ReceptorCollection[1] = { 11, 1, GAUCHE, 255, 0, 0, false };
|
|
ReceptorCollection[2] = { 6, 3, BAS, 0, 0, 0, false }; // Receptor WHITE
|
|
ReceptorCollection[3] = { 3, 1, BAS, 255, 0, 255, false }; // Receptor WHITE
|
|
ReceptorCollection[4] = { 9, 1, BAS, 255, 255, 0, false }; // Receptor WHITE
|
|
|
|
|
|
TreasureCollection[0] = {1,5, T_RED, false, PIERRE_BLANCHE, 100, true };
|
|
TreasureCollection[1] = {11,5, T_YELLOW, false, PIERRE_BLANCHE, 100, true };
|
|
TreasureCollection[2] = {11,7, T_GREEN, false, PIERRE_BLANCHE, 100, true };
|
|
TreasureCollection[3] = {1,7, T_BLUE, false, PIERRE_BLANCHE, 100, true };
|
|
|
|
ObstaclesCollection[0] = {1,1,BLOCK_STONE};
|
|
ObstaclesCollection[1] = {3,1,BLOCK_STONE};
|
|
ObstaclesCollection[2] = {5,1,BLOCK_STONE};
|
|
|
|
ObstaclesCollection[3] = {7,1,BLOCK_STONE};
|
|
ObstaclesCollection[4] = {9,1,BLOCK_STONE};
|
|
ObstaclesCollection[5] = {11,1,BLOCK_STONE};
|
|
|
|
ObstaclesCollection[6] = {1,9,BLOCK_STONE};
|
|
ObstaclesCollection[7] = {3,9,BLOCK_STONE};
|
|
ObstaclesCollection[8] = {5,9,BLOCK_STONE};
|
|
|
|
ObstaclesCollection[9] = {7,9,BLOCK_STONE};
|
|
ObstaclesCollection[10] = {9,9,BLOCK_STONE};
|
|
ObstaclesCollection[11] = {11,9,BLOCK_STONE};
|
|
|
|
ObstaclesCollection[12] = {6,3,BLOCK_STONE};
|
|
|
|
|
|
BossCollection[0] = { 6, 4, 1, 11, HORIZONTAL, GAUCHE, BIGBOSS };
|
|
}
|
|
else if (numLevel==32) // VALIDATED [OK]
|
|
{
|
|
currentLevel = numLevel;
|
|
|
|
LEVELCOLOR = 0;
|
|
SIZE_MAP_X=13;
|
|
SIZE_MAP_Y=11;
|
|
|
|
NbReceptorsLevel = 0;
|
|
NbDoorsLevel = 1;
|
|
NbBlocksLevel = 4;
|
|
NbTreasureLevel = 1;
|
|
NbObstacleLevel = 32;
|
|
NbMonsterLevel = 0;
|
|
NbBossLevel = 0;
|
|
|
|
BlocksCollection = (Blocks*) malloc( NbBlocksLevel * sizeof( Blocks) );
|
|
ReceptorCollection = (Receptor*) malloc( NbReceptorsLevel * sizeof( Receptor) );
|
|
DoorCollection = (Door*) malloc( NbDoorsLevel * sizeof( Door) );
|
|
TreasureCollection = (Treasure*) malloc( NbTreasureLevel * sizeof( Treasure) );
|
|
ObstaclesCollection = (Obstacle*) malloc( NbObstacleLevel * sizeof( Obstacle) );
|
|
MonstersCollection = (Monster*) malloc( NbMonsterLevel * sizeof( Monster) );
|
|
BossCollection = (Boss*) malloc( NbBossLevel * sizeof( Boss ) );
|
|
|
|
Map[numLevel].x=0;
|
|
Map[numLevel].y=-9;
|
|
Map[numLevel].R=255;
|
|
Map[numLevel].G=255;
|
|
Map[numLevel].B=255;
|
|
Map[numLevel].A=255;
|
|
Map[numLevel].visited=true;
|
|
Map[numLevel].doorWest=false;
|
|
Map[numLevel].doorNorth=false;
|
|
Map[numLevel].doorEast=false;
|
|
Map[numLevel].doorSouth=true;
|
|
|
|
|
|
joueur = { 6, 9, HAUT };
|
|
lumiere = { 3, 5, 1,1,1,0, false };
|
|
|
|
BlocksCollection[0] = { 2, 4, 255, 0, 0, 127, TRANSPARENT };
|
|
BlocksCollection[1] = { 2, 5, 0, 255, 0, 127, TRANSPARENT };
|
|
BlocksCollection[2] = { 2, 6, 0, 0, 255, 127, TRANSPARENT };
|
|
BlocksCollection[3] = { 10, 5, 0, 0, 0, 255, OPAQUE };
|
|
|
|
BlocRouge = &BlocksCollection[0];
|
|
BlocVert = &BlocksCollection[1];
|
|
BlocBleu = &BlocksCollection[2];
|
|
BlocNoir = &BlocksCollection[3];
|
|
|
|
//DoorCollection[0] = { 6,0, HAUT, false, true, 0, { -1,-1, -1 },6}; // Door NORTH
|
|
//DoorCollection[1] = { 0, 5, GAUCHE, false, true, 0, { -1, -1, -1 }, 9}; // Door WEST
|
|
//DoorCollection[1] = { 12, 5, DROITE, false, true, 0, { -1, -1, -1 }, 10}; // Door EAST
|
|
DoorCollection[0] = { 6, 10, BAS, false, true, 0, { -1, -1, -1 }, 31}; // Door SOUTH
|
|
|
|
TreasureCollection[0] = {6,2, T_BLUE, false, WHITE_FRAGMENT, 10000, true };
|
|
|
|
ObstaclesCollection[0] = {1,1,BLOCK_STONE};
|
|
ObstaclesCollection[1] = {2,1,BLOCK_STONE};
|
|
ObstaclesCollection[2] = {1,2,BLOCK_STONE};
|
|
|
|
ObstaclesCollection[3] = {11,1,BLOCK_STONE};
|
|
ObstaclesCollection[4] = {10,1,BLOCK_STONE};
|
|
ObstaclesCollection[5] = {11,2,BLOCK_STONE};
|
|
|
|
ObstaclesCollection[6] = {1,9,BLOCK_STONE};
|
|
ObstaclesCollection[7] = {2,9,BLOCK_STONE};
|
|
ObstaclesCollection[8] = {1,8,BLOCK_STONE};
|
|
|
|
ObstaclesCollection[9] = {11,9,BLOCK_STONE};
|
|
ObstaclesCollection[10] = {10,9,BLOCK_STONE};
|
|
ObstaclesCollection[11] = {11,8,BLOCK_STONE};
|
|
|
|
ObstaclesCollection[12] = {4,1,BLOCK_WATER};
|
|
ObstaclesCollection[13] = {4,2,BLOCK_WATER};
|
|
ObstaclesCollection[14] = {4,3,BLOCK_WATER};
|
|
ObstaclesCollection[15] = {4,4,BLOCK_WATER};
|
|
ObstaclesCollection[16] = {5,4,BLOCK_WATER};
|
|
ObstaclesCollection[17] = {5,5,BLOCK_WATER};
|
|
ObstaclesCollection[18] = {5,6,BLOCK_WATER};
|
|
ObstaclesCollection[19] = {5,7,BLOCK_WATER};
|
|
ObstaclesCollection[20] = {5,8,BLOCK_WATER};
|
|
ObstaclesCollection[21] = {5,9,BLOCK_WATER};
|
|
|
|
|
|
ObstaclesCollection[22] = {8,1,BLOCK_WATER};
|
|
ObstaclesCollection[23] = {8,2,BLOCK_WATER};
|
|
ObstaclesCollection[24] = {8,3,BLOCK_WATER};
|
|
ObstaclesCollection[25] = {8,4,BLOCK_WATER};
|
|
ObstaclesCollection[26] = {7,4,BLOCK_WATER};
|
|
ObstaclesCollection[27] = {7,5,BLOCK_WATER};
|
|
ObstaclesCollection[28] = {7,6,BLOCK_WATER};
|
|
ObstaclesCollection[29] = {7,7,BLOCK_WATER};
|
|
ObstaclesCollection[30] = {7,8,BLOCK_WATER};
|
|
ObstaclesCollection[31] = {7,9,BLOCK_WATER};
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (needcorrection==true)
|
|
adjustLevel( numLevel );
|
|
}
|
|
|
|
|
|
void synchroniseGame( void )
|
|
{
|
|
score = sauvegarde.currentScore[0]*256+sauvegarde.currentScore[1];
|
|
currentLevel = sauvegarde.currentLevel;
|
|
difficulty = sauvegarde.currentDifficulty;
|
|
|
|
life = sauvegarde.currentLife;
|
|
|
|
RedFrag = sauvegarde.redFrag==1 ? true : false;
|
|
GreenFrag = sauvegarde.greenFrag==1 ? true : false;
|
|
BlueFrag = sauvegarde.blueFrag==1 ? true : false;
|
|
BlackFrag = sauvegarde.blackFrag==1 ? true : false;
|
|
WhiteFrag = sauvegarde.whiteFrag==1 ? true : false;
|
|
|
|
for( unsigned char k =0; k<33; k++)
|
|
{
|
|
if (sauvegarde.visitedLevels[k]==0x01)
|
|
{
|
|
loadLevel( k );
|
|
}
|
|
else Map[k].visited= false;
|
|
}
|
|
}
|
|
|
|
|
|
void exitAndFree( void )
|
|
{
|
|
free(BlocksCollection);
|
|
free(ReceptorCollection);
|
|
free(DoorCollection);
|
|
free(TreasureCollection);
|
|
free(ObstaclesCollection);
|
|
free(MonstersCollection);
|
|
free(BossCollection);
|
|
free(BulletCollection);
|
|
}
|
|
|
|
void initWalls( void )
|
|
{
|
|
murs[0] = { HORIZONTAL, OFFSET_X+SIZE*1, OFFSET_X+SIZE*(SIZE_MAP_X-1), OFFSET_Y+SIZE };
|
|
murs[1] = { VERTICAL, OFFSET_Y+SIZE*1, OFFSET_Y+SIZE*(SIZE_MAP_Y-1), OFFSET_X+SIZE*(SIZE_MAP_X-1) };
|
|
murs[2] = { HORIZONTAL, OFFSET_X+SIZE*1, OFFSET_X+SIZE*(SIZE_MAP_X-1), OFFSET_Y+SIZE*(SIZE_MAP_Y-1) };
|
|
murs[3] = { VERTICAL, OFFSET_Y+SIZE*1, OFFSET_Y+SIZE*(SIZE_MAP_Y-1), OFFSET_X+SIZE };
|
|
|
|
for(unsigned char k=0; k<SIZE_MAP_X; k++)
|
|
dprint_opt( OFFSET_X+SIZE*k+SIZE/2, OFFSET_Y-SIZE/2, C_WHITE, C_NONE, DTEXT_CENTER, DTEXT_MIDDLE, "%d", k );
|
|
|
|
for( unsigned char k=1; k<SIZE_MAP_Y; k++)
|
|
dprint_opt( OFFSET_X-SIZE/2, OFFSET_Y+k*SIZE+SIZE/2, C_WHITE, C_NONE, DTEXT_CENTER, DTEXT_MIDDLE, "%d", k );
|
|
}
|
|
|
|
void renderMap( void )
|
|
{
|
|
//dimage(OFFSET_X, OFFSET_Y, &mapbackgrd);
|
|
unsigned int OFFSET_X_TILE = 0;
|
|
|
|
OFFSET_X_TILE = 64*LEVELCOLOR;
|
|
|
|
for(unsigned char x=0; x<SIZE_MAP_X; x++)
|
|
for( unsigned char y=0; y<SIZE_MAP_Y; y++)
|
|
{
|
|
unsigned int lX=OFFSET_X+x*SIZE;
|
|
unsigned int lY=OFFSET_Y+y*SIZE;
|
|
|
|
if(y==0)
|
|
{
|
|
if (x==0)
|
|
dsubimage( lX, lY, &leveltiles, OFFSET_X_TILE+0,0,16,16, DIMAGE_NONE);
|
|
else if (x==SIZE_MAP_X-1)
|
|
dsubimage( lX, lY, &leveltiles, OFFSET_X_TILE+16,0,16,16, DIMAGE_NONE);
|
|
else
|
|
dsubimage( lX, lY, &leveltiles, OFFSET_X_TILE+32,0,16,16, DIMAGE_NONE);
|
|
}
|
|
else if(y==SIZE_MAP_Y-1)
|
|
{
|
|
if (x==0)
|
|
dsubimage( lX, lY, &leveltiles, OFFSET_X_TILE+0,16,16,16, DIMAGE_NONE);
|
|
else if (x==SIZE_MAP_X-1)
|
|
dsubimage( lX, lY, &leveltiles, OFFSET_X_TILE+16,16,16,16, DIMAGE_NONE);
|
|
else
|
|
dsubimage( lX, lY, &leveltiles, OFFSET_X_TILE+48,16,16,16, DIMAGE_NONE);
|
|
}
|
|
else
|
|
{
|
|
if (x==0)
|
|
dsubimage( lX, lY, &leveltiles, OFFSET_X_TILE+48,0,16,16, DIMAGE_NONE);
|
|
else if (x==SIZE_MAP_X-1)
|
|
dsubimage( lX, lY, &leveltiles, OFFSET_X_TILE+32,16,16,16, DIMAGE_NONE);
|
|
else if ((x+y)%2==0)
|
|
dsubimage( lX, lY, &leveltiles, OFFSET_X_TILE+0,32,16,16, DIMAGE_NONE);
|
|
else
|
|
dsubimage( lX, lY, &leveltiles, OFFSET_X_TILE+16,32,16,16, DIMAGE_NONE);
|
|
}
|
|
}
|
|
}
|
|
|
|
int computeLightModification( unsigned int currentCellX, unsigned int currentCellY, unsigned char* R, unsigned char* G, unsigned char* B, unsigned char* A )
|
|
{
|
|
if (*A!=ALPHA_BLOQUE)
|
|
{
|
|
for( unsigned char k=0; k<NbBlocksLevel; k++ )
|
|
{
|
|
if (BlocksCollection[k].x == currentCellX)
|
|
if (BlocksCollection[k].y == currentCellY)
|
|
{
|
|
if (*R!=BlocNoir->R || *G!=BlocNoir->G || *B!=BlocNoir->B || *A!=ALPHA_OPAQUE ) // We check if the light is not already a black ray
|
|
{
|
|
if (BlocksCollection[k].type == OPAQUE)
|
|
{
|
|
if (*R==lumiere.R && *G==lumiere.G && *B==lumiere.B && *A==lumiere.A)
|
|
{
|
|
*R = (*R-lumiere.R) & BlocksCollection[k].R;
|
|
*G = (*G-lumiere.G) & BlocksCollection[k].G;
|
|
*B = (*B-lumiere.B) & BlocksCollection[k].B;
|
|
*A = ALPHA_OPAQUE;
|
|
}
|
|
else
|
|
{
|
|
*R = *R & BlocksCollection[k].R;
|
|
*G = *G & BlocksCollection[k].G;
|
|
*B = *B & BlocksCollection[k].B;
|
|
*A = ALPHA_OPAQUE;
|
|
}
|
|
}
|
|
if (BlocksCollection[k].type == TRANSPARENT)
|
|
{
|
|
if (*R==lumiere.R && *G==lumiere.G && *B==lumiere.B && *A==lumiere.A)
|
|
{
|
|
*R = (*R-lumiere.R) | BlocksCollection[k].R;
|
|
*G = (*G-lumiere.G) | BlocksCollection[k].G;
|
|
*B = (*B-lumiere.B) | BlocksCollection[k].B;
|
|
*A = ALPHA_TRANSPARENT;
|
|
}
|
|
else
|
|
{
|
|
*R = *R | BlocksCollection[k].R;
|
|
*G = *G | BlocksCollection[k].G;
|
|
*B = *B | BlocksCollection[k].B;
|
|
*A = ALPHA_TRANSPARENT;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for( unsigned char k=0; k<NbObstacleLevel; k++ )
|
|
{
|
|
if (ObstaclesCollection[k].type!=BLOCK_WATER)
|
|
if (ObstaclesCollection[k].x == currentCellX)
|
|
if (ObstaclesCollection[k].y == currentCellY)
|
|
{
|
|
*A = ALPHA_BLOQUE;
|
|
}
|
|
}
|
|
|
|
if (*A == ALPHA_BLOQUE) return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void rayCast( unsigned int x1, unsigned int y1, unsigned int x2, unsigned int y2, unsigned char* Rs, unsigned char* Gs, unsigned char* Bs, unsigned char* As )
|
|
{
|
|
// Cette fonction est un algo type BRESENHAM qui lance un rayon depuis la lumière jusqu'à chaque pixel des murs
|
|
// Elle analyse la présence de blocs de glace de couleurs qui peuvent changer la couleur de la lumière du départ (Rs, Gs, Bs)
|
|
// Elle dessine le point sur le mur de la bonne couleur
|
|
|
|
// ATTENTION : toujours mettre x1 et y1 comme étant en premier et correspondant à la source de lumière !!!!
|
|
|
|
|
|
char currentCellX = -1;
|
|
char currentCellY = -1;
|
|
|
|
unsigned int x,y;
|
|
int dx,dy,swp,temp,s1,s2,p,i;
|
|
|
|
x=x1;
|
|
y=y1;
|
|
dx=_abs(x2-x1);
|
|
dy=_abs(y2-y1);
|
|
s1=_sgn(x2-x1);
|
|
s2=_sgn(y2-y1);
|
|
swp=0;
|
|
|
|
if(dy>dx)
|
|
{
|
|
temp=dx;
|
|
dx=dy;
|
|
dy=temp;
|
|
swp=1;
|
|
}
|
|
p=2*dy-dx;
|
|
for(i=0; i<dx; i+=SPEEDUP_RAY)
|
|
{
|
|
currentCellX = (x-OFFSET_X)/SIZE;
|
|
currentCellY = (y-OFFSET_Y)/SIZE;
|
|
int result = computeLightModification( currentCellX, currentCellY, Rs, Gs, Bs, As );
|
|
|
|
|
|
if (result==1)
|
|
{
|
|
if ((*Rs!=lumiere.R || *Gs!=lumiere.G || *Bs!=lumiere.B) && *As==ALPHA_BLOQUE)
|
|
_boxRGBA( x-1, y-1, x+1, y+1, *Rs, *Gs, *Bs, 255 );
|
|
|
|
// if (*Rs==lumiere.R && *Gs==lumiere.G && *Bs==lumiere.B && *As==ALPHA_BLOQUE)
|
|
// _boxRGBA( x-1, y-1, x+1, y+1, *Rs, *Gs, *Bs, 255 );
|
|
}
|
|
else if (result==0)
|
|
{
|
|
_pixelRGBA( x, y, *Rs, *Gs, *Bs, *As );
|
|
}
|
|
|
|
|
|
while(p>=0)
|
|
{
|
|
p=p-2*dx;
|
|
if(swp)
|
|
x+=s1*SPEEDUP_RAY;
|
|
else
|
|
y+=s2*SPEEDUP_RAY;
|
|
}
|
|
p=p+2*dy;
|
|
if(swp)
|
|
y+=s2*SPEEDUP_RAY;
|
|
else
|
|
x+=s1*SPEEDUP_RAY;
|
|
}
|
|
}
|
|
|
|
void renderWalls( void )
|
|
{
|
|
unsigned char lR = lumiere.R;
|
|
unsigned char lG = lumiere.G;
|
|
unsigned char lB = lumiere.B;
|
|
unsigned char lA = lumiere.A;
|
|
|
|
unsigned int lX = SIZE*lumiere.x+OFFSET_X+SIZE/2;
|
|
unsigned int lY = SIZE*lumiere.y+OFFSET_Y+SIZE/2;
|
|
|
|
for( unsigned char k=0; k<4; k++ )
|
|
{
|
|
if (murs[k].direction == HORIZONTAL)
|
|
for( unsigned int z=murs[k].mini; z<=murs[k].maxi; z+=SPEEDUP_WALL)
|
|
{
|
|
lR = lumiere.R;
|
|
lG = lumiere.G;
|
|
lB = lumiere.B;
|
|
lA = lumiere.A;
|
|
|
|
rayCast( lX, lY, z, murs[k].fixe, &lR,&lG,&lB,&lA );
|
|
|
|
if (lR!=lumiere.R || lG!=lumiere.G || lB!=lumiere.B || lA!=lumiere.A )
|
|
{
|
|
if(lA!=ALPHA_BLOQUE)
|
|
{
|
|
_pixelRGBA( z, murs[k].fixe+1, lR,lG,lB, 255 );
|
|
_pixelRGBA( z, murs[k].fixe, lR,lG,lB, 255 );
|
|
_pixelRGBA( z, murs[k].fixe-1, lR,lG,lB, 255 );
|
|
}
|
|
}
|
|
}
|
|
|
|
if (murs[k].direction == VERTICAL)
|
|
for( unsigned int z=murs[k].mini; z<=murs[k].maxi; z+=SPEEDUP_WALL)
|
|
{
|
|
lR = lumiere.R;
|
|
lG = lumiere.G;
|
|
lB = lumiere.B;
|
|
lA = lumiere.A;
|
|
|
|
rayCast( lX, lY, murs[k].fixe, z, &lR,&lG,&lB,&lA );
|
|
|
|
if (lR!=lumiere.R || lG!=lumiere.G || lB!=lumiere.B || lA!=lumiere.A )
|
|
{
|
|
if (lA!=ALPHA_BLOQUE)
|
|
{
|
|
_pixelRGBA( murs[k].fixe+1, z, lR,lG,lB,255 );
|
|
_pixelRGBA( murs[k].fixe, z, lR,lG,lB,255 );
|
|
_pixelRGBA( murs[k].fixe-1, z, lR,lG,lB,255 );
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
void renderObstacles( int passnumber )
|
|
{
|
|
if (passnumber == LAYER_BELOW_RAYS)
|
|
{
|
|
|
|
for( unsigned char k=0; k<NbObstacleLevel; k++ )
|
|
{
|
|
unsigned int Xb = ObstaclesCollection[k].x;
|
|
unsigned int Yb = ObstaclesCollection[k].y;
|
|
unsigned char Tb = ObstaclesCollection[k].type;
|
|
|
|
unsigned int lX = SIZE*Xb+OFFSET_X;
|
|
unsigned int lY = SIZE*Yb+OFFSET_Y;
|
|
|
|
if (Tb==BLOCK_WATER) dsubimage( lX, lY, &sprites, 64,112,16,16, DIMAGE_NONE);
|
|
}
|
|
}
|
|
else if (passnumber == LAYER_ABOVE_RAYS)
|
|
{
|
|
|
|
for( unsigned char k=0; k<NbObstacleLevel; k++ )
|
|
{
|
|
unsigned int Xb = ObstaclesCollection[k].x;
|
|
unsigned int Yb = ObstaclesCollection[k].y;
|
|
unsigned char Tb = ObstaclesCollection[k].type;
|
|
|
|
unsigned int lX = SIZE*Xb+OFFSET_X;
|
|
unsigned int lY = SIZE*Yb+OFFSET_Y;
|
|
|
|
if (Tb==BLOCK_STONE) dsubimage( lX, lY, &sprites, 0,112,16,16, DIMAGE_NONE);
|
|
else if (Tb==BLOCK_MOON) dsubimage( lX, lY, &sprites, 16,112,16,16, DIMAGE_NONE);
|
|
else if (Tb==BLOCK_WOOD) dsubimage( lX, lY, &sprites, 32,112,16,16, DIMAGE_NONE);
|
|
else if (Tb==BLOCK_SUN) dsubimage( lX, lY, &sprites, 48,112,16,16, DIMAGE_NONE);
|
|
}
|
|
}
|
|
}
|
|
|
|
void renderTreasures( void )
|
|
{
|
|
for( unsigned char k=0; k<NbTreasureLevel; k++ )
|
|
{
|
|
unsigned int Xb = TreasureCollection[k].x;
|
|
unsigned int Yb = TreasureCollection[k].y;
|
|
chest Tb = TreasureCollection[k].type;
|
|
bool Ob = TreasureCollection[k].isopen;
|
|
bool Vis = TreasureCollection[k].isvisible;
|
|
|
|
unsigned int lX = SIZE*Xb+OFFSET_X;
|
|
unsigned int lY = SIZE*Yb+OFFSET_Y;
|
|
|
|
if (Vis==true)
|
|
{
|
|
|
|
if (Tb==T_RED)
|
|
{
|
|
if (Ob==false)
|
|
{
|
|
dsubimage( lX, lY, &chests, 0,0,16,16, DIMAGE_NONE);
|
|
}
|
|
else
|
|
{
|
|
dsubimage( lX, lY, &chests, 0,48,16,16, DIMAGE_NONE);
|
|
}
|
|
}
|
|
else if (Tb==T_YELLOW)
|
|
{
|
|
if (Ob==false)
|
|
{
|
|
dsubimage( lX, lY, &chests, 16,0,16,16, DIMAGE_NONE);
|
|
}
|
|
else
|
|
{
|
|
dsubimage( lX, lY, &chests, 16,48,16,16, DIMAGE_NONE);
|
|
}
|
|
}
|
|
else if (Tb==T_GREEN)
|
|
{
|
|
if (Ob==false)
|
|
{
|
|
dsubimage( lX, lY, &chests, 32,0,16,16, DIMAGE_NONE);
|
|
}
|
|
else
|
|
{
|
|
dsubimage( lX, lY, &chests, 32,48,16,16, DIMAGE_NONE);
|
|
}
|
|
}
|
|
else if (Tb==T_BLUE)
|
|
{
|
|
if (Ob==false)
|
|
{
|
|
dsubimage( lX, lY, &chests, 48,0,16,16, DIMAGE_NONE);
|
|
}
|
|
else
|
|
{
|
|
dsubimage( lX, lY, &chests, 48,48,16,16, DIMAGE_NONE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void renderMovable( void )
|
|
{
|
|
for( unsigned char k=0; k<NbBlocksLevel; k++ )
|
|
{
|
|
unsigned int Xb = BlocksCollection[k].x;
|
|
unsigned int Yb = BlocksCollection[k].y;
|
|
unsigned char Rb = BlocksCollection[k].R;
|
|
unsigned char Gb = BlocksCollection[k].G;
|
|
unsigned char Bb = BlocksCollection[k].B;
|
|
//unsigned char Ab = BlocksCollection[k].A;
|
|
|
|
unsigned int lX = SIZE*Xb+OFFSET_X;
|
|
unsigned int lY = SIZE*Yb+OFFSET_Y;
|
|
|
|
if (Rb==255 && Gb==0 && Bb==0) dsubimage( lX, lY, &sprites, 16,0,16,16, DIMAGE_NONE);
|
|
else if (Rb==0 && Gb==0 && Bb==255) dsubimage( lX, lY, &sprites, 32,0,16,16, DIMAGE_NONE);
|
|
else if (Rb==0 && Gb==255 && Bb==0) dsubimage( lX, lY, &sprites, 48,0,16,16, DIMAGE_NONE);
|
|
else if (Rb==0 && Gb==0 && Bb==0) dsubimage( lX, lY, &sprites, 64,0,16,16, DIMAGE_NONE);
|
|
else if (Rb==255 && Gb==255 && Bb==255) dsubimage( lX, lY, &sprites, 0,0,16,16, DIMAGE_NONE);
|
|
}
|
|
|
|
}
|
|
|
|
void renderPlayer( void )
|
|
{
|
|
unsigned int lX = SIZE*joueur.x+OFFSET_X;
|
|
unsigned int lY = SIZE*joueur.y+OFFSET_Y;
|
|
|
|
if (direction==BAS)
|
|
{
|
|
if (mouvement==true)
|
|
{
|
|
if (frame==0) dsubimage( lX, lY-11, &player, 0,0,16,16, DIMAGE_NONE);
|
|
else if (frame==1) dsubimage( lX, lY-6, &player, 16,0,16,16, DIMAGE_NONE);
|
|
else if (frame==2) dsubimage( lX, lY, &player, 32,0,16,16, DIMAGE_NONE);
|
|
|
|
frame++;
|
|
if (frame==3) mouvement = false;
|
|
}
|
|
else
|
|
{
|
|
dsubimage( lX, lY, &player, 0,0,16,16, DIMAGE_NONE);
|
|
frame = 0;
|
|
}
|
|
}
|
|
else if (direction==DROITE)
|
|
{
|
|
if (mouvement==true)
|
|
{
|
|
if (frame==0) dsubimage( lX-11, lY, &player, 0,16,16,16, DIMAGE_NONE);
|
|
else if (frame==1) dsubimage( lX-6, lY, &player, 16,16,16,16, DIMAGE_NONE);
|
|
else if (frame==2) dsubimage( lX, lY, &player, 32,16,16,16, DIMAGE_NONE);
|
|
|
|
frame++;
|
|
if (frame==3) mouvement = false;
|
|
}
|
|
else
|
|
{
|
|
dsubimage( lX, lY, &player, 0,16,16,16, DIMAGE_NONE);
|
|
frame = 0;
|
|
}
|
|
}
|
|
else if (direction==HAUT)
|
|
{
|
|
if (mouvement==true)
|
|
{
|
|
if (frame==0) dsubimage( lX, lY+11, &player, 0,32,16,16, DIMAGE_NONE);
|
|
else if (frame==1) dsubimage( lX, lY+6, &player, 16,32,16,16, DIMAGE_NONE);
|
|
else if (frame==2) dsubimage( lX, lY, &player, 32,32,16,16, DIMAGE_NONE);
|
|
|
|
frame++;
|
|
if (frame==3) mouvement = false;
|
|
}
|
|
else
|
|
{
|
|
dsubimage( lX, lY, &player, 0,32,16,16, DIMAGE_NONE);
|
|
frame = 0;
|
|
}
|
|
}
|
|
else if (direction==GAUCHE)
|
|
{
|
|
if (mouvement==true)
|
|
{
|
|
if (frame==0) dsubimage( lX+11, lY, &player, 0,48,16,16, DIMAGE_NONE);
|
|
else if (frame==1) dsubimage( lX+6, lY, &player, 16,48,16,16, DIMAGE_NONE);
|
|
else if (frame==2) dsubimage( lX, lY, &player, 32,48,16,16, DIMAGE_NONE);
|
|
|
|
frame++;
|
|
if (frame==3) mouvement = false;
|
|
}
|
|
else
|
|
{
|
|
dsubimage( lX, lY, &player, 0,48,16,16, DIMAGE_NONE);
|
|
frame = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
void renderLight( void )
|
|
{
|
|
unsigned int lX = SIZE*lumiere.x+OFFSET_X;
|
|
unsigned int lY = SIZE*lumiere.y+OFFSET_Y;
|
|
|
|
frame_light%=6;
|
|
dsubimage( lX, lY, &light, 16*frame_light,0,16,16, DIMAGE_NONE);
|
|
frame_light++;
|
|
}
|
|
|
|
void drawMinimap( void )
|
|
{
|
|
for( unsigned char k=0; k<=NB_LEVELS; k++ )
|
|
{
|
|
if (Map[k].visited==true)
|
|
{
|
|
unsigned char R= Map[k].R;
|
|
unsigned char G= Map[k].G;
|
|
unsigned char B= Map[k].B;
|
|
unsigned char A= Map[k].A;
|
|
|
|
unsigned int lX = OFFSET_X_MINIMAP + Map[k].x*(SCALE_X_MINIMAP+2);
|
|
unsigned int lY = OFFSET_Y_MINIMAP + Map[k].y*(SCALE_Y_MINIMAP+2);
|
|
|
|
_boxRGBA( lX-4, lY-3, lX+4, lY+3, R, G, B, A>>1 );
|
|
_rectangleRGBA( lX-4, lY-3, lX+4, lY+3, R, G, B, 255);
|
|
|
|
if (Map[k].doorWest==true) _lineRGBA( lX-5, lY-1, lX-5, lY+1, 255, 255, 255, 255);
|
|
if (Map[k].doorEast==true) _lineRGBA( lX+5, lY-1, lX+5, lY+1, 255, 255, 255, 255);
|
|
if (Map[k].doorNorth==true) _lineRGBA( lX-1, lY-4, lX+1, lY-4, 255, 255, 255, 255);
|
|
if (Map[k].doorSouth==true) _lineRGBA( lX-1, lY+4, lX+1, lY+4, 255, 255, 255, 255);
|
|
|
|
if (k==currentLevel)
|
|
{
|
|
_rectangleRGBA( lX-4, lY-3, lX+4, lY+3, 255, 0, 255, 255);
|
|
_rectangleRGBA( lX-3, lY-2, lX+3, lY+2, 255, 0, 255, 255);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void drawInterface( void )
|
|
{
|
|
unsigned int midX, midY;
|
|
|
|
dsubimage( 232, 0, &parchemin, 0,0, 164, 210, DIMAGE_NONE);
|
|
dfont( &font_fantasy );
|
|
|
|
dprint( 256, 36, C_RGB(150,150,150), "MAGIC Light %s", RevShort);
|
|
dprint( 255, 35, C_BLACK, "MAGIC Light %s", RevShort);
|
|
|
|
dfont( &font_tiny );
|
|
|
|
dprint( 251, 56, C_RGB(150,150,150), "Score : %d", score );
|
|
dprint( 250, 55, C_BLACK, "Score : %d", score );
|
|
|
|
dprint( 251, 66, C_RGB(150,150,150), "Level : %d", currentLevel );
|
|
dprint( 250, 65, C_BLACK, "Level : %d", currentLevel );
|
|
|
|
dprint( 316, 56, C_RGB(150,150,150), "Life :");
|
|
dprint( 315, 55, C_BLACK, "Life :" );
|
|
|
|
for( unsigned char k = 0; k< life; k++)
|
|
{
|
|
dsubimage( 340 + k*8, 57, &hearts, 8, 0, 8, 8, DIMAGE_NONE);
|
|
}
|
|
|
|
for( unsigned char k = life; k< lifeMax; k++)
|
|
{
|
|
dsubimage( 340 + k*8, 57, &hearts, 0, 0, 8, 8, DIMAGE_NONE);
|
|
}
|
|
|
|
|
|
if (WhiteFrag==true) dsubimage( 340, 66, &fragments, 0, 0, 32, 32, DIMAGE_NONE);
|
|
if (BlackFrag==true) dsubimage( 340, 66, &fragments, 32, 0, 32, 32, DIMAGE_NONE);
|
|
if (RedFrag==true) dsubimage( 340, 66, &fragments, 64, 0, 32, 32, DIMAGE_NONE);
|
|
if (GreenFrag==true) dsubimage( 340, 66, &fragments, 96, 0, 32, 32, DIMAGE_NONE);
|
|
if (BlueFrag==true) dsubimage( 340, 66, &fragments, 128, 0, 32, 32, DIMAGE_NONE);
|
|
|
|
|
|
midY=(200+224)/2;
|
|
|
|
midX=(66)/2;
|
|
dsubimage( midX-8, midY-8, &player, 0,0,16,16, DIMAGE_NONE);
|
|
|
|
midX+=66;
|
|
dsubimage( midX-8, midY-8, &light, 0,0,16,16, DIMAGE_NONE);
|
|
|
|
midX+=66;
|
|
dsubimage( midX-8, midY-8, &sprites, 16,0,16,16, DIMAGE_NONE);
|
|
|
|
midX+=66;
|
|
dsubimage( midX-8, midY-8, &sprites, 48,0,16,16, DIMAGE_NONE);
|
|
|
|
midX+=66;
|
|
dsubimage( midX-8, midY-8, &sprites, 32,0,16,16, DIMAGE_NONE);
|
|
|
|
midX+=66;
|
|
dsubimage( midX-8, midY-8, &sprites, 64,0,16,16, DIMAGE_NONE);
|
|
|
|
if (selected >=1 && selected <=6)
|
|
{
|
|
|
|
if (frame_cursor==0) dsubimage( 66*(selected)-33-11, midY-11, &cursor, 0,0,22,22, DIMAGE_NONE);
|
|
else if (frame_cursor==1) dsubimage( 66*(selected)-33-11, midY-11, &cursor, 22,0,22,22, DIMAGE_NONE);
|
|
else if (frame_cursor==2) dsubimage( 66*(selected)-33-11, midY-11, &cursor, 44,0,22,22, DIMAGE_NONE);
|
|
else if (frame_cursor==3) dsubimage( 66*(selected)-33-11, midY-11, &cursor, 22,0,22,22, DIMAGE_NONE);
|
|
}
|
|
}
|
|
|
|
|
|
bool isValidMove( selection selected, unsigned char x, unsigned char y, orientations sens )
|
|
{
|
|
if (selected == JOUEUR)
|
|
for(unsigned char k=0; k<NbDoorsLevel; k++)
|
|
{
|
|
if ( x==DoorCollection[k].x && y==DoorCollection[k].y)
|
|
{
|
|
if (DoorCollection[k].isdoor && DoorCollection[k].isopen)
|
|
{
|
|
updateCurrentState( );
|
|
loadLevel( DoorCollection[k].nextLevelNumber );
|
|
joueur = { 11-10*x/12, 9-8*y/10, sens };
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (x<1 || x>SIZE_MAP_X-2 || y<1 || y>SIZE_MAP_Y-2)
|
|
{
|
|
return false;
|
|
}
|
|
else if (selected == JOUEUR)
|
|
{
|
|
if (x==lumiere.x && y==lumiere.y) return false;
|
|
else if (x==BlocRouge->x && y==BlocRouge->y) return false;
|
|
else if (x==BlocVert->x && y==BlocVert->y) return false;
|
|
else if (x==BlocBleu->x && y==BlocBleu->y) return false;
|
|
else if (x==BlocNoir->x && y==BlocNoir->y) return false;
|
|
else
|
|
{
|
|
for (unsigned char k =0; k<NbObstacleLevel; k++)
|
|
if (ObstaclesCollection[k].x==x && ObstaclesCollection[k].y==y)
|
|
return false;
|
|
return true;
|
|
}
|
|
}
|
|
else if (selected == LUMIERE)
|
|
{
|
|
if (x==joueur.x && y==joueur.y) return false;
|
|
else
|
|
{
|
|
for (unsigned char k =0; k<NbObstacleLevel; k++)
|
|
if (ObstaclesCollection[k].x==x && ObstaclesCollection[k].y==y)
|
|
return false;
|
|
return true;
|
|
}
|
|
}
|
|
else if (selected == ROUGE)
|
|
{
|
|
if (x==joueur.x && y==joueur.y) return false;
|
|
else if (x==BlocVert->x && y==BlocVert->y) return false;
|
|
else if (x==BlocBleu->x && y==BlocBleu->y) return false;
|
|
else if (x==BlocNoir->x && y==BlocNoir->y) return false;
|
|
else
|
|
{
|
|
for (unsigned char k =0; k<NbObstacleLevel; k++)
|
|
if (ObstaclesCollection[k].x==x && ObstaclesCollection[k].y==y)
|
|
return false;
|
|
return true;
|
|
}
|
|
}
|
|
else if (selected == VERT)
|
|
{
|
|
if (x==joueur.x && y==joueur.y) return false;
|
|
else if (x==BlocRouge->x && y==BlocRouge->y) return false;
|
|
else if (x==BlocBleu->x && y==BlocBleu->y) return false;
|
|
else if (x==BlocNoir->x && y==BlocNoir->y) return false;
|
|
else
|
|
{
|
|
for (unsigned char k =0; k<NbObstacleLevel; k++)
|
|
if (ObstaclesCollection[k].x==x && ObstaclesCollection[k].y==y)
|
|
return false;
|
|
return true;
|
|
}
|
|
}
|
|
else if (selected == BLEU)
|
|
{
|
|
if (x==joueur.x && y==joueur.y) return false;
|
|
else if (x==BlocRouge->x && y==BlocRouge->y) return false;
|
|
else if (x==BlocVert->x && y==BlocVert->y) return false;
|
|
else if (x==BlocNoir->x && y==BlocNoir->y) return false;
|
|
else
|
|
{
|
|
for (unsigned char k =0; k<NbObstacleLevel; k++)
|
|
if (ObstaclesCollection[k].x==x && ObstaclesCollection[k].y==y)
|
|
return false;
|
|
return true;
|
|
}
|
|
}
|
|
else if (selected == NOIR)
|
|
{
|
|
if (x==joueur.x && y==joueur.y) return false;
|
|
else if (x==BlocRouge->x && y==BlocRouge->y) return false;
|
|
else if (x==BlocVert->x && y==BlocVert->y) return false;
|
|
else if (x==BlocBleu->x && y==BlocBleu->y) return false;
|
|
else
|
|
{
|
|
for (unsigned char k =0; k<NbObstacleLevel; k++)
|
|
if (ObstaclesCollection[k].x==x && ObstaclesCollection[k].y==y)
|
|
return false;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void gameMechanics( selection what, orientations touche )
|
|
{
|
|
if (touche==GAUCHE)
|
|
{
|
|
if (what==JOUEUR && isValidMove(JOUEUR, joueur.x-1, joueur.y, touche ))
|
|
{
|
|
joueur.x--;
|
|
frame=0;
|
|
direction=GAUCHE;
|
|
mouvement=true;
|
|
}
|
|
else if (what==JOUEUR && !isValidMove(JOUEUR, joueur.x-1, joueur.y, touche))
|
|
{
|
|
frame=0;
|
|
direction=GAUCHE;
|
|
}
|
|
else if (what==LUMIERE && isValidMove(LUMIERE, lumiere.x-1, lumiere.y, touche)) lumiere.x--;
|
|
else if (what==ROUGE && isValidMove(ROUGE, BlocRouge->x-1, BlocRouge->y, touche )) BlocRouge->x--;
|
|
else if (what==VERT && isValidMove(VERT, BlocVert->x-1, BlocVert->y, touche)) BlocVert->x--;
|
|
else if (what==BLEU && isValidMove(BLEU, BlocBleu->x-1, BlocBleu->y, touche)) BlocBleu->x--;
|
|
else if (what==NOIR && isValidMove(NOIR, BlocNoir->x-1, BlocNoir->y, touche)) BlocNoir->x--;
|
|
}
|
|
if (touche==DROITE)
|
|
{
|
|
if (what==JOUEUR && isValidMove(JOUEUR, joueur.x+1, joueur.y, touche))
|
|
{
|
|
joueur.x++;
|
|
frame=0;
|
|
direction=DROITE;
|
|
mouvement=true;
|
|
}
|
|
else if (what==JOUEUR && !isValidMove(JOUEUR, joueur.x+1, joueur.y, touche))
|
|
{
|
|
frame=0;
|
|
direction=DROITE;
|
|
}
|
|
else if (what==LUMIERE && isValidMove(LUMIERE, lumiere.x+1, lumiere.y, touche)) lumiere.x++;
|
|
else if (what==ROUGE && isValidMove(ROUGE, BlocRouge->x+1, BlocRouge->y, touche)) BlocRouge->x++;
|
|
else if (what==VERT && isValidMove(VERT, BlocVert->x+1, BlocVert->y, touche)) BlocVert->x++;
|
|
else if (what==BLEU && isValidMove(BLEU, BlocBleu->x+1, BlocBleu->y, touche)) BlocBleu->x++;
|
|
else if (what==NOIR && isValidMove(NOIR, BlocNoir->x+1, BlocNoir->y, touche)) BlocNoir->x++;
|
|
}
|
|
if (touche==HAUT)
|
|
{
|
|
if (what==JOUEUR && isValidMove(JOUEUR, joueur.x, joueur.y-1, touche))
|
|
{
|
|
joueur.y--;
|
|
frame=0;
|
|
direction=HAUT;
|
|
mouvement=true;
|
|
}
|
|
else if (what==JOUEUR && !isValidMove(JOUEUR, joueur.x, joueur.y-1, touche))
|
|
{
|
|
frame=0;
|
|
direction=HAUT;
|
|
}
|
|
else if (what==LUMIERE && isValidMove(LUMIERE, lumiere.x, lumiere.y-1, touche)) lumiere.y--;
|
|
else if (what==ROUGE && isValidMove(ROUGE, BlocRouge->x, BlocRouge->y-1, touche)) BlocRouge->y--;
|
|
else if (what==VERT && isValidMove(VERT, BlocVert->x, BlocVert->y-1, touche)) BlocVert->y--;
|
|
else if (what==BLEU && isValidMove(BLEU, BlocBleu->x, BlocBleu->y-1, touche)) BlocBleu->y--;
|
|
else if (what==NOIR && isValidMove(NOIR, BlocNoir->x, BlocNoir->y-1, touche)) BlocNoir->y--;
|
|
}
|
|
if (touche==BAS)
|
|
{
|
|
if (what==JOUEUR && isValidMove(JOUEUR, joueur.x, joueur.y+1, touche))
|
|
{
|
|
joueur.y++;
|
|
frame=0;
|
|
direction=BAS;
|
|
mouvement=true;
|
|
}
|
|
else if (what==JOUEUR && !isValidMove(JOUEUR, joueur.x, joueur.y+1, touche))
|
|
{
|
|
frame=0;
|
|
direction=BAS;
|
|
}
|
|
else if (what==LUMIERE && isValidMove(LUMIERE, lumiere.x, lumiere.y+1, touche)) lumiere.y++;
|
|
else if (what==ROUGE && isValidMove(ROUGE, BlocRouge->x, BlocRouge->y+1, touche)) BlocRouge->y++;
|
|
else if (what==VERT && isValidMove(VERT, BlocVert->x, BlocVert->y+1, touche)) BlocVert->y++;
|
|
else if (what==BLEU && isValidMove(BLEU, BlocBleu->x, BlocBleu->y+1, touche)) BlocBleu->y++;
|
|
else if (what==NOIR && isValidMove(NOIR, BlocNoir->x, BlocNoir->y+1, touche)) BlocNoir->y++;
|
|
}
|
|
}
|
|
|
|
bool checkNextPositionMonster( unsigned int Xtarget, unsigned int Ytarget, unsigned int direction )
|
|
{
|
|
|
|
for( unsigned char k=0; k<NbObstacleLevel; k++)
|
|
{
|
|
if (ObstaclesCollection[k].x==Xtarget && ObstaclesCollection[k].y==Ytarget)
|
|
return false;
|
|
}
|
|
|
|
//if (Xtarget>=lumiere.x-1 && Xtarget<=lumiere.x+1 && Ytarget>=lumiere.y-1 && Ytarget<=lumiere.y+1)
|
|
if (Xtarget==lumiere.x && Ytarget==lumiere.y)
|
|
{
|
|
return false;
|
|
}
|
|
else if (Xtarget==joueur.x && Ytarget==joueur.y)
|
|
{
|
|
if (life>0) life--;
|
|
return false;
|
|
}
|
|
else if (Xtarget==BlocRouge->x && Ytarget==BlocRouge->y)
|
|
{
|
|
if (direction==HAUT)
|
|
{
|
|
if (isValidMove( ROUGE, BlocRouge->x, BlocRouge->y-1, HAUT))
|
|
{
|
|
BlocRouge->y-=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==BAS)
|
|
{
|
|
if (isValidMove( ROUGE, BlocRouge->x, BlocRouge->y+1, BAS))
|
|
{
|
|
BlocRouge->y+=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==GAUCHE)
|
|
{
|
|
if (isValidMove( ROUGE, BlocRouge->x-1, BlocRouge->y, GAUCHE))
|
|
{
|
|
BlocRouge->x-=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==DROITE)
|
|
{
|
|
if (isValidMove( ROUGE, BlocRouge->x+1, BlocRouge->y, DROITE))
|
|
{
|
|
BlocRouge->x+=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
}
|
|
else if (Xtarget==BlocVert->x && Ytarget==BlocVert->y)
|
|
{
|
|
if (direction==HAUT)
|
|
{
|
|
if (isValidMove( VERT, BlocVert->x, BlocVert->y-1, HAUT))
|
|
{
|
|
BlocVert->y-=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==BAS)
|
|
{
|
|
if (isValidMove( VERT, BlocVert->x, BlocVert->y+1, BAS))
|
|
{
|
|
BlocVert->y+=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==GAUCHE)
|
|
{
|
|
if (isValidMove( VERT, BlocVert->x-1, BlocVert->y, GAUCHE))
|
|
{
|
|
BlocVert->x-=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==DROITE)
|
|
{
|
|
if (isValidMove( VERT, BlocVert->x+1, BlocVert->y, DROITE))
|
|
{
|
|
BlocVert->x+=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
}
|
|
else if (Xtarget==BlocBleu->x && Ytarget==BlocBleu->y)
|
|
{
|
|
if (direction==HAUT)
|
|
{
|
|
if (isValidMove( BLEU, BlocBleu->x, BlocBleu->y-1, HAUT))
|
|
{
|
|
BlocBleu->y-=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==BAS)
|
|
{
|
|
if (isValidMove( BLEU, BlocBleu->x, BlocBleu->y+1, BAS))
|
|
{
|
|
BlocBleu->y+=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==GAUCHE)
|
|
{
|
|
if (isValidMove( BLEU, BlocBleu->x-1, BlocBleu->y, GAUCHE))
|
|
{
|
|
BlocBleu->x-=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==DROITE)
|
|
{
|
|
if (isValidMove( BLEU, BlocBleu->x+1, BlocBleu->y, DROITE))
|
|
{
|
|
BlocBleu->x+=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
}
|
|
else if (Xtarget==BlocNoir->x && Ytarget==BlocNoir->y)
|
|
{
|
|
if (direction==HAUT)
|
|
{
|
|
if (isValidMove( NOIR, BlocNoir->x, BlocNoir->y-1, HAUT))
|
|
{
|
|
BlocNoir->y-=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==BAS)
|
|
{
|
|
if (isValidMove( NOIR, BlocNoir->x, BlocNoir->y+1, BAS))
|
|
{
|
|
BlocNoir->y+=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==GAUCHE)
|
|
{
|
|
if (isValidMove( NOIR, BlocNoir->x-1, BlocNoir->y, GAUCHE))
|
|
{
|
|
BlocNoir->x-=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==DROITE)
|
|
{
|
|
if (isValidMove( NOIR, BlocNoir->x+1, BlocNoir->y, DROITE))
|
|
{
|
|
BlocNoir->x+=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void updateMonsters( void )
|
|
{
|
|
for( unsigned char k=0; k<NbMonsterLevel; k++ )
|
|
{
|
|
unsigned int X = MonstersCollection[k].xcur;
|
|
unsigned int Y = MonstersCollection[k].ycur;
|
|
unsigned char mini = MonstersCollection[k].mini;
|
|
unsigned char maxi = MonstersCollection[k].maxi;
|
|
unsigned int direction = MonstersCollection[k].direction;
|
|
unsigned int sens = MonstersCollection[k].sens;
|
|
|
|
if (direction==VERTICAL)
|
|
{
|
|
if (sens==BAS)
|
|
{
|
|
if (Y<maxi && checkNextPositionMonster( X, Y+1, BAS)==true)
|
|
{
|
|
MonstersCollection[k].ycur++;
|
|
MonstersCollection[k].sens=BAS;
|
|
}
|
|
else
|
|
{
|
|
MonstersCollection[k].sens=HAUT;
|
|
}
|
|
}
|
|
else if (sens==HAUT)
|
|
{
|
|
if (Y>mini && checkNextPositionMonster( X, Y-1, HAUT)==true)
|
|
{
|
|
MonstersCollection[k].ycur--;
|
|
MonstersCollection[k].sens=HAUT;
|
|
}
|
|
else
|
|
{
|
|
MonstersCollection[k].sens=BAS;
|
|
}
|
|
}
|
|
}
|
|
else if (direction==HORIZONTAL)
|
|
{
|
|
|
|
if (sens==DROITE)
|
|
{
|
|
if (X<maxi && checkNextPositionMonster( X+1, Y, DROITE)==true)
|
|
{
|
|
MonstersCollection[k].xcur++;
|
|
MonstersCollection[k].sens=DROITE;
|
|
}
|
|
else
|
|
{
|
|
MonstersCollection[k].sens=GAUCHE;
|
|
}
|
|
}
|
|
else if (sens==GAUCHE)
|
|
{
|
|
if (X>mini && checkNextPositionMonster( X-1, Y, GAUCHE)==true)
|
|
{
|
|
MonstersCollection[k].xcur--;
|
|
MonstersCollection[k].sens=GAUCHE;
|
|
}
|
|
else
|
|
{
|
|
MonstersCollection[k].sens=DROITE;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
void renderMonsters( void )
|
|
{
|
|
for( unsigned char k=0; k<NbMonsterLevel; k++ )
|
|
{
|
|
unsigned int lX = SIZE*MonstersCollection[k].xcur+OFFSET_X;
|
|
unsigned int lY = SIZE*MonstersCollection[k].ycur+OFFSET_Y;
|
|
unsigned char mini = MonstersCollection[k].mini;
|
|
unsigned char maxi = MonstersCollection[k].maxi;
|
|
unsigned int direction = MonstersCollection[k].direction;
|
|
unsigned int sens = MonstersCollection[k].sens;
|
|
unsigned int type = MonstersCollection[k].kind;
|
|
|
|
|
|
|
|
unsigned int OFFSET_X_MONSTER = 48*type;
|
|
|
|
if (direction==VERTICAL)
|
|
{
|
|
|
|
/*
|
|
if (true)
|
|
{
|
|
_lineRGBA( lX+SIZE/2, mini*SIZE+OFFSET_Y+SIZE/2, lX+SIZE/2, maxi*SIZE+OFFSET_Y+SIZE/2, 255, 0, 0, 255 );
|
|
_lineRGBA( lX+1+SIZE/2, mini*SIZE+OFFSET_Y+SIZE/2, lX+1+SIZE/2, maxi*SIZE+OFFSET_Y+SIZE/2, 255, 0, 0, 255 );
|
|
_lineRGBA( lX-1+SIZE/2, mini*SIZE+OFFSET_Y+SIZE/2, lX-1+SIZE/2, maxi*SIZE+OFFSET_Y+SIZE/2, 255, 0, 0, 255 );
|
|
}
|
|
*/
|
|
if (sens==BAS && MonstersCollection[k].ycur<maxi)
|
|
{
|
|
if (frame_monster==0) dsubimage( lX, lY, &monstres, OFFSET_X_MONSTER,0,16,16, DIMAGE_NONE);
|
|
else if (frame_monster==1) dsubimage( lX, lY+3, &monstres, OFFSET_X_MONSTER+16,0,16,16, DIMAGE_NONE);
|
|
else if (frame_monster==2) dsubimage( lX, lY+5, &monstres, OFFSET_X_MONSTER+32,0,16,16, DIMAGE_NONE);
|
|
else if (frame_monster==3) dsubimage( lX, lY+8, &monstres, OFFSET_X_MONSTER,0,16,16, DIMAGE_NONE);
|
|
else if (frame_monster==4) dsubimage( lX, lY+11, &monstres, OFFSET_X_MONSTER+16,0,16,16, DIMAGE_NONE);
|
|
else if (frame_monster==5) dsubimage( lX, lY+13, &monstres, OFFSET_X_MONSTER+32,0,16,16, DIMAGE_NONE);
|
|
}
|
|
else if (sens==BAS && MonstersCollection[k].ycur==maxi)
|
|
{
|
|
dsubimage( lX, lY, &monstres, OFFSET_X_MONSTER,0,16,16, DIMAGE_NONE);
|
|
}
|
|
else if (sens==HAUT && MonstersCollection[k].ycur>mini)
|
|
{
|
|
if (frame_monster==0) dsubimage( lX, lY, &monstres, OFFSET_X_MONSTER,32,16,16, DIMAGE_NONE);
|
|
else if (frame_monster==1) dsubimage( lX, lY-3, &monstres, OFFSET_X_MONSTER+16,32,16,16, DIMAGE_NONE);
|
|
else if (frame_monster==2) dsubimage( lX, lY-5, &monstres, OFFSET_X_MONSTER+32,32,16,16, DIMAGE_NONE);
|
|
else if (frame_monster==3) dsubimage( lX, lY-8, &monstres, OFFSET_X_MONSTER,32,16,16, DIMAGE_NONE);
|
|
else if (frame_monster==4) dsubimage( lX, lY-11, &monstres, OFFSET_X_MONSTER+16,32,16,16, DIMAGE_NONE);
|
|
else if (frame_monster==5) dsubimage( lX, lY-13, &monstres, OFFSET_X_MONSTER+32,32,16,16, DIMAGE_NONE);
|
|
}
|
|
else if (sens==HAUT && MonstersCollection[k].ycur==mini)
|
|
{
|
|
dsubimage( lX, lY, &monstres, OFFSET_X_MONSTER,32,16,16, DIMAGE_NONE);
|
|
}
|
|
}
|
|
|
|
else if (direction==HORIZONTAL)
|
|
{
|
|
|
|
/*
|
|
if (true)
|
|
{
|
|
_lineRGBA( mini*SIZE+OFFSET_X+SIZE/2, lY+SIZE/2, maxi*SIZE+OFFSET_X+SIZE/2, lY+SIZE/2, 255, 0, 0, 255 );
|
|
_lineRGBA( mini*SIZE+OFFSET_X+SIZE/2, lY+1+SIZE/2, maxi*SIZE+OFFSET_X+SIZE/2, lY+1+SIZE/2, 255, 0, 0, 255 );
|
|
_lineRGBA( mini*SIZE+OFFSET_X+SIZE/2, lY-1+SIZE/2, maxi*SIZE+OFFSET_X+SIZE/2, lY-1+SIZE/2, 255, 0, 0, 255 );
|
|
}
|
|
*/
|
|
|
|
if (sens==GAUCHE && MonstersCollection[k].xcur>mini)
|
|
{
|
|
if (frame_monster==0) dsubimage( lX, lY, &monstres, OFFSET_X_MONSTER,48,16,16, DIMAGE_NONE);
|
|
else if (frame_monster==1) dsubimage( lX-3, lY, &monstres, OFFSET_X_MONSTER+16,48,16,16, DIMAGE_NONE);
|
|
else if (frame_monster==2) dsubimage( lX-5, lY, &monstres, OFFSET_X_MONSTER+32,48,16,16, DIMAGE_NONE);
|
|
else if (frame_monster==3) dsubimage( lX-8, lY, &monstres, OFFSET_X_MONSTER,48,16,16, DIMAGE_NONE);
|
|
else if (frame_monster==4) dsubimage( lX-11, lY, &monstres, OFFSET_X_MONSTER+16,48,16,16, DIMAGE_NONE);
|
|
else if (frame_monster==5) dsubimage( lX-13, lY, &monstres, OFFSET_X_MONSTER+32,48,16,16, DIMAGE_NONE);
|
|
}
|
|
else if (sens==GAUCHE && MonstersCollection[k].xcur==mini)
|
|
{
|
|
dsubimage( lX, lY, &monstres, OFFSET_X_MONSTER,48,16,16, DIMAGE_NONE);
|
|
}
|
|
else if (sens==DROITE && MonstersCollection[k].xcur<maxi)
|
|
{
|
|
if (frame_monster==0) dsubimage( lX, lY, &monstres, OFFSET_X_MONSTER,16,16,16, DIMAGE_NONE);
|
|
else if (frame_monster==1) dsubimage( lX+3, lY, &monstres, OFFSET_X_MONSTER+16,16,16,16, DIMAGE_NONE);
|
|
else if (frame_monster==2) dsubimage( lX+5, lY, &monstres, OFFSET_X_MONSTER+32,16,16,16, DIMAGE_NONE);
|
|
else if (frame_monster==3) dsubimage( lX+8, lY, &monstres, OFFSET_X_MONSTER,16,16,16, DIMAGE_NONE);
|
|
else if (frame_monster==4) dsubimage( lX+11, lY, &monstres, OFFSET_X_MONSTER+16,16,16,16, DIMAGE_NONE);
|
|
else if (frame_monster==5) dsubimage( lX+13, lY, &monstres, OFFSET_X_MONSTER+32,16,16,16, DIMAGE_NONE);
|
|
}
|
|
else if (sens==DROITE && MonstersCollection[k].xcur==maxi)
|
|
{
|
|
dsubimage( lX, lY, &monstres, OFFSET_X_MONSTER,16,16,16, DIMAGE_NONE);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
frame_monster++;
|
|
if (frame_monster==6)
|
|
{
|
|
updateMonsters();
|
|
frame_monster=0;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool checkNextPositionBoss( unsigned int Xtarget, unsigned int Ytarget, unsigned int direction )
|
|
{
|
|
|
|
for( unsigned char k=0; k<NbObstacleLevel; k++)
|
|
{
|
|
if (ObstaclesCollection[k].x==Xtarget && ObstaclesCollection[k].y==Ytarget)
|
|
return false;
|
|
}
|
|
|
|
//if (Xtarget>=lumiere.x-1 && Xtarget<=lumiere.x+1 && Ytarget>=lumiere.y-1 && Ytarget<=lumiere.y+1)
|
|
if (Xtarget==lumiere.x && Ytarget==lumiere.y)
|
|
{
|
|
return false;
|
|
}
|
|
else if (Xtarget==joueur.x && Ytarget==joueur.y)
|
|
{
|
|
if (life>0) life--;
|
|
return false;
|
|
}
|
|
else if (Xtarget==BlocRouge->x && Ytarget==BlocRouge->y)
|
|
{
|
|
if (direction==HAUT)
|
|
{
|
|
if (isValidMove( ROUGE, BlocRouge->x, BlocRouge->y-1, HAUT))
|
|
{
|
|
BlocRouge->y-=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==BAS)
|
|
{
|
|
if (isValidMove( ROUGE, BlocRouge->x, BlocRouge->y+1, BAS))
|
|
{
|
|
BlocRouge->y+=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==GAUCHE)
|
|
{
|
|
if (isValidMove( ROUGE, BlocRouge->x-1, BlocRouge->y, GAUCHE))
|
|
{
|
|
BlocRouge->x-=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==DROITE)
|
|
{
|
|
if (isValidMove( ROUGE, BlocRouge->x+1, BlocRouge->y, DROITE))
|
|
{
|
|
BlocRouge->x+=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
}
|
|
else if (Xtarget==BlocVert->x && Ytarget==BlocVert->y)
|
|
{
|
|
if (direction==HAUT)
|
|
{
|
|
if (isValidMove( VERT, BlocVert->x, BlocVert->y-1, HAUT))
|
|
{
|
|
BlocVert->y-=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==BAS)
|
|
{
|
|
if (isValidMove( VERT, BlocVert->x, BlocVert->y+1, BAS))
|
|
{
|
|
BlocVert->y+=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==GAUCHE)
|
|
{
|
|
if (isValidMove( VERT, BlocVert->x-1, BlocVert->y, GAUCHE))
|
|
{
|
|
BlocVert->x-=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==DROITE)
|
|
{
|
|
if (isValidMove( VERT, BlocVert->x+1, BlocVert->y, DROITE))
|
|
{
|
|
BlocVert->x+=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
}
|
|
else if (Xtarget==BlocBleu->x && Ytarget==BlocBleu->y)
|
|
{
|
|
if (direction==HAUT)
|
|
{
|
|
if (isValidMove( BLEU, BlocBleu->x, BlocBleu->y-1, HAUT))
|
|
{
|
|
BlocBleu->y-=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==BAS)
|
|
{
|
|
if (isValidMove( BLEU, BlocBleu->x, BlocBleu->y+1, BAS))
|
|
{
|
|
BlocBleu->y+=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==GAUCHE)
|
|
{
|
|
if (isValidMove( BLEU, BlocBleu->x-1, BlocBleu->y, GAUCHE))
|
|
{
|
|
BlocBleu->x-=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==DROITE)
|
|
{
|
|
if (isValidMove( BLEU, BlocBleu->x+1, BlocBleu->y, DROITE))
|
|
{
|
|
BlocBleu->x+=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
}
|
|
else if (Xtarget==BlocNoir->x && Ytarget==BlocNoir->y)
|
|
{
|
|
if (direction==HAUT)
|
|
{
|
|
if (isValidMove( NOIR, BlocNoir->x, BlocNoir->y-1, HAUT))
|
|
{
|
|
BlocNoir->y-=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==BAS)
|
|
{
|
|
if (isValidMove( NOIR, BlocNoir->x, BlocNoir->y+1, BAS))
|
|
{
|
|
BlocNoir->y+=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==GAUCHE)
|
|
{
|
|
if (isValidMove( NOIR, BlocNoir->x-1, BlocNoir->y, GAUCHE))
|
|
{
|
|
BlocNoir->x-=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else if (direction==DROITE)
|
|
{
|
|
if (isValidMove( NOIR, BlocNoir->x+1, BlocNoir->y, DROITE))
|
|
{
|
|
BlocNoir->x+=1;
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void updateBoss( void )
|
|
{
|
|
for( unsigned char k=0; k<NbBossLevel; k++ )
|
|
{
|
|
unsigned int X = BossCollection[k].xcur;
|
|
unsigned int Y = BossCollection[k].ycur;
|
|
unsigned char mini = BossCollection[k].mini;
|
|
unsigned char maxi = BossCollection[k].maxi;
|
|
unsigned int direction = BossCollection[k].direction;
|
|
unsigned int sens = BossCollection[k].sens;
|
|
|
|
if (direction==VERTICAL)
|
|
{
|
|
if (sens==BAS)
|
|
{
|
|
if (Y<maxi && checkNextPositionMonster( X, Y+1, BAS)==true)
|
|
{
|
|
BossCollection[k].ycur++;
|
|
BossCollection[k].sens=BAS;
|
|
}
|
|
else
|
|
{
|
|
BossCollection[k].sens=HAUT;
|
|
}
|
|
}
|
|
else if (sens==HAUT)
|
|
{
|
|
if (Y>mini && checkNextPositionMonster( X, Y-1, HAUT)==true)
|
|
{
|
|
BossCollection[k].ycur--;
|
|
BossCollection[k].sens=HAUT;
|
|
}
|
|
else
|
|
{
|
|
BossCollection[k].sens=BAS;
|
|
}
|
|
}
|
|
}
|
|
else if (direction==HORIZONTAL)
|
|
{
|
|
|
|
if (sens==DROITE)
|
|
{
|
|
if (X<maxi && checkNextPositionMonster( X+1, Y, DROITE)==true)
|
|
{
|
|
BossCollection[k].xcur++;
|
|
BossCollection[k].sens=DROITE;
|
|
}
|
|
else
|
|
{
|
|
BossCollection[k].sens=GAUCHE;
|
|
}
|
|
}
|
|
else if (sens==GAUCHE)
|
|
{
|
|
if (X>mini && checkNextPositionMonster( X-1, Y, GAUCHE)==true)
|
|
{
|
|
BossCollection[k].xcur--;
|
|
BossCollection[k].sens=GAUCHE;
|
|
}
|
|
else
|
|
{
|
|
BossCollection[k].sens=DROITE;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void renderBoss( void )
|
|
{
|
|
|
|
for( unsigned char k=0; k<NbBossLevel; k++ )
|
|
{
|
|
unsigned int lX = SIZE*BossCollection[k].xcur+OFFSET_X;
|
|
unsigned int lY = SIZE*BossCollection[k].ycur+OFFSET_Y - 2; //Boss are 18 pixel high instead of 16
|
|
unsigned char mini = BossCollection[k].mini;
|
|
unsigned char maxi = BossCollection[k].maxi;
|
|
unsigned int direction = BossCollection[k].direction;
|
|
unsigned int sens = BossCollection[k].sens;
|
|
unsigned int type = BossCollection[k].color;
|
|
|
|
if (type ==BIGBOSS)
|
|
{
|
|
lX -= 8;
|
|
lY -= 14;
|
|
|
|
unsigned int OFFSET_X_MONSTER = 0;
|
|
|
|
if (direction==VERTICAL)
|
|
{
|
|
|
|
/*
|
|
if (true)
|
|
{
|
|
_lineRGBA( lX+SIZE/2, mini*SIZE+OFFSET_Y+SIZE/2, lX+SIZE/2, maxi*SIZE+OFFSET_Y+SIZE/2, 255, 0, 0, 255 );
|
|
_lineRGBA( lX+1+SIZE/2, mini*SIZE+OFFSET_Y+SIZE/2, lX+1+SIZE/2, maxi*SIZE+OFFSET_Y+SIZE/2, 255, 0, 0, 255 );
|
|
_lineRGBA( lX-1+SIZE/2, mini*SIZE+OFFSET_Y+SIZE/2, lX-1+SIZE/2, maxi*SIZE+OFFSET_Y+SIZE/2, 255, 0, 0, 255 );
|
|
}
|
|
*/
|
|
if (sens==BAS && BossCollection[k].ycur<maxi)
|
|
{
|
|
if (frame_boss==0) dsubimage( lX, lY, &bigboss, OFFSET_X_MONSTER,64,32,32, DIMAGE_NONE);
|
|
else if (frame_boss==1) dsubimage( lX, lY+3, &bigboss, OFFSET_X_MONSTER+32,64,32,32, DIMAGE_NONE);
|
|
else if (frame_boss==2) dsubimage( lX, lY+5, &bigboss, OFFSET_X_MONSTER+64,64,32,32, DIMAGE_NONE);
|
|
else if (frame_boss==3) dsubimage( lX, lY+8, &bigboss, OFFSET_X_MONSTER,64,32,32, DIMAGE_NONE);
|
|
else if (frame_boss==4) dsubimage( lX, lY+11, &bigboss, OFFSET_X_MONSTER+32,64,32,32, DIMAGE_NONE);
|
|
else if (frame_boss==5) dsubimage( lX, lY+13, &bigboss, OFFSET_X_MONSTER+64,64,32,32, DIMAGE_NONE);
|
|
}
|
|
else if (sens==BAS && BossCollection[k].ycur==maxi)
|
|
{
|
|
dsubimage( lX, lY, &bigboss, OFFSET_X_MONSTER,64,32,32, DIMAGE_NONE);
|
|
}
|
|
else if (sens==HAUT && BossCollection[k].ycur>mini)
|
|
{
|
|
if (frame_boss==0) dsubimage( lX, lY, &bigboss, OFFSET_X_MONSTER,0,32,32, DIMAGE_NONE);
|
|
else if (frame_boss==1) dsubimage( lX, lY-3, &bigboss, OFFSET_X_MONSTER+32,0,32,32, DIMAGE_NONE);
|
|
else if (frame_boss==2) dsubimage( lX, lY-5, &bigboss, OFFSET_X_MONSTER+64,0,32,32, DIMAGE_NONE);
|
|
else if (frame_boss==3) dsubimage( lX, lY-8, &bigboss, OFFSET_X_MONSTER,32,0,32, DIMAGE_NONE);
|
|
else if (frame_boss==4) dsubimage( lX, lY-11, &bigboss, OFFSET_X_MONSTER+32,0,32,32, DIMAGE_NONE);
|
|
else if (frame_boss==5) dsubimage( lX, lY-13, &bigboss, OFFSET_X_MONSTER+64,0,32,32, DIMAGE_NONE);
|
|
}
|
|
else if (sens==HAUT && BossCollection[k].ycur==mini)
|
|
{
|
|
dsubimage( lX, lY, &bigboss, OFFSET_X_MONSTER,0,32,32, DIMAGE_NONE);
|
|
}
|
|
}
|
|
|
|
else if (direction==HORIZONTAL)
|
|
{
|
|
|
|
/*
|
|
if (true)
|
|
{
|
|
_lineRGBA( mini*SIZE+OFFSET_X+SIZE/2, lY+SIZE/2, maxi*SIZE+OFFSET_X+SIZE/2, lY+SIZE/2, 255, 0, 0, 255 );
|
|
_lineRGBA( mini*SIZE+OFFSET_X+SIZE/2, lY+1+SIZE/2, maxi*SIZE+OFFSET_X+SIZE/2, lY+1+SIZE/2, 255, 0, 0, 255 );
|
|
_lineRGBA( mini*SIZE+OFFSET_X+SIZE/2, lY-1+SIZE/2, maxi*SIZE+OFFSET_X+SIZE/2, lY-1+SIZE/2, 255, 0, 0, 255 );
|
|
}
|
|
*/
|
|
|
|
if (sens==GAUCHE && BossCollection[k].xcur>mini)
|
|
{
|
|
if (frame_boss==0) dsubimage( lX, lY, &bigboss, OFFSET_X_MONSTER,96,32,32, DIMAGE_NONE);
|
|
else if (frame_boss==1) dsubimage( lX-3, lY, &bigboss, OFFSET_X_MONSTER+32,96,32,32, DIMAGE_NONE);
|
|
else if (frame_boss==2) dsubimage( lX-5, lY, &bigboss, OFFSET_X_MONSTER+64,96,32,32, DIMAGE_NONE);
|
|
else if (frame_boss==3) dsubimage( lX-8, lY, &bigboss, OFFSET_X_MONSTER,96,32,32, DIMAGE_NONE);
|
|
else if (frame_boss==4) dsubimage( lX-11, lY, &bigboss, OFFSET_X_MONSTER+32,96,32,32, DIMAGE_NONE);
|
|
else if (frame_boss==5) dsubimage( lX-13, lY, &bigboss, OFFSET_X_MONSTER+64,96,32,32, DIMAGE_NONE);
|
|
}
|
|
else if (sens==GAUCHE && BossCollection[k].xcur==mini)
|
|
{
|
|
dsubimage( lX, lY, &bigboss, OFFSET_X_MONSTER,96,32,32, DIMAGE_NONE);
|
|
}
|
|
else if (sens==DROITE && BossCollection[k].xcur<maxi)
|
|
{
|
|
if (frame_boss==0) dsubimage( lX, lY, &bigboss, OFFSET_X_MONSTER,32,32,32, DIMAGE_NONE);
|
|
else if (frame_boss==1) dsubimage( lX+3, lY, &bigboss, OFFSET_X_MONSTER+32,32,32,32, DIMAGE_NONE);
|
|
else if (frame_boss==2) dsubimage( lX+5, lY, &bigboss, OFFSET_X_MONSTER+64,32,32,32, DIMAGE_NONE);
|
|
else if (frame_boss==3) dsubimage( lX+8, lY, &bigboss, OFFSET_X_MONSTER,32,32,32, DIMAGE_NONE);
|
|
else if (frame_boss==4) dsubimage( lX+11, lY, &bigboss, OFFSET_X_MONSTER+32,32,32,32, DIMAGE_NONE);
|
|
else if (frame_boss==5) dsubimage( lX+13, lY, &bigboss, OFFSET_X_MONSTER+64,32,32,32, DIMAGE_NONE);
|
|
}
|
|
else if (sens==DROITE && BossCollection[k].xcur==maxi)
|
|
{
|
|
dsubimage( lX, lY, &bigboss, OFFSET_X_MONSTER,32,32,32, DIMAGE_NONE);
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
unsigned int OFFSET_X_MONSTER = 48*type;
|
|
|
|
|
|
if (direction==VERTICAL)
|
|
{
|
|
|
|
/*
|
|
if (true)
|
|
{
|
|
_lineRGBA( lX+SIZE/2, mini*SIZE+OFFSET_Y+SIZE/2, lX+SIZE/2, maxi*SIZE+OFFSET_Y+SIZE/2, 255, 0, 0, 255 );
|
|
_lineRGBA( lX+1+SIZE/2, mini*SIZE+OFFSET_Y+SIZE/2, lX+1+SIZE/2, maxi*SIZE+OFFSET_Y+SIZE/2, 255, 0, 0, 255 );
|
|
_lineRGBA( lX-1+SIZE/2, mini*SIZE+OFFSET_Y+SIZE/2, lX-1+SIZE/2, maxi*SIZE+OFFSET_Y+SIZE/2, 255, 0, 0, 255 );
|
|
}
|
|
*/
|
|
if (sens==BAS && BossCollection[k].ycur<maxi)
|
|
{
|
|
if (frame_boss==0) dsubimage( lX, lY, &bossmages, OFFSET_X_MONSTER,36,16,18, DIMAGE_NONE);
|
|
else if (frame_boss==1) dsubimage( lX, lY+3, &bossmages, OFFSET_X_MONSTER+16,36,16,18, DIMAGE_NONE);
|
|
else if (frame_boss==2) dsubimage( lX, lY+5, &bossmages, OFFSET_X_MONSTER+32,36,16,18, DIMAGE_NONE);
|
|
else if (frame_boss==3) dsubimage( lX, lY+8, &bossmages, OFFSET_X_MONSTER,36,16,18, DIMAGE_NONE);
|
|
else if (frame_boss==4) dsubimage( lX, lY+11, &bossmages, OFFSET_X_MONSTER+16,36,16,18, DIMAGE_NONE);
|
|
else if (frame_boss==5) dsubimage( lX, lY+13, &bossmages, OFFSET_X_MONSTER+32,36,16,18, DIMAGE_NONE);
|
|
}
|
|
else if (sens==BAS && BossCollection[k].ycur==maxi)
|
|
{
|
|
dsubimage( lX, lY, &bossmages, OFFSET_X_MONSTER,36,16,18, DIMAGE_NONE);
|
|
}
|
|
else if (sens==HAUT && BossCollection[k].ycur>mini)
|
|
{
|
|
if (frame_boss==0) dsubimage( lX, lY, &bossmages, OFFSET_X_MONSTER,0,16,18, DIMAGE_NONE);
|
|
else if (frame_boss==1) dsubimage( lX, lY-3, &bossmages, OFFSET_X_MONSTER+16,0,16,18, DIMAGE_NONE);
|
|
else if (frame_boss==2) dsubimage( lX, lY-5, &bossmages, OFFSET_X_MONSTER+32,0,16,18, DIMAGE_NONE);
|
|
else if (frame_boss==3) dsubimage( lX, lY-8, &bossmages, OFFSET_X_MONSTER,0,16,18, DIMAGE_NONE);
|
|
else if (frame_boss==4) dsubimage( lX, lY-11, &bossmages, OFFSET_X_MONSTER+16,0,16,18, DIMAGE_NONE);
|
|
else if (frame_boss==5) dsubimage( lX, lY-13, &bossmages, OFFSET_X_MONSTER+32,0,16,18, DIMAGE_NONE);
|
|
}
|
|
else if (sens==HAUT && BossCollection[k].ycur==mini)
|
|
{
|
|
dsubimage( lX, lY, &bossmages, OFFSET_X_MONSTER,0,16,18, DIMAGE_NONE);
|
|
}
|
|
}
|
|
|
|
else if (direction==HORIZONTAL)
|
|
{
|
|
|
|
/*
|
|
if (true)
|
|
{
|
|
_lineRGBA( mini*SIZE+OFFSET_X+SIZE/2, lY+SIZE/2, maxi*SIZE+OFFSET_X+SIZE/2, lY+SIZE/2, 255, 0, 0, 255 );
|
|
_lineRGBA( mini*SIZE+OFFSET_X+SIZE/2, lY+1+SIZE/2, maxi*SIZE+OFFSET_X+SIZE/2, lY+1+SIZE/2, 255, 0, 0, 255 );
|
|
_lineRGBA( mini*SIZE+OFFSET_X+SIZE/2, lY-1+SIZE/2, maxi*SIZE+OFFSET_X+SIZE/2, lY-1+SIZE/2, 255, 0, 0, 255 );
|
|
}
|
|
*/
|
|
|
|
if (sens==GAUCHE && BossCollection[k].xcur>mini)
|
|
{
|
|
if (frame_boss==0) dsubimage( lX, lY, &bossmages, OFFSET_X_MONSTER,54,16,18, DIMAGE_NONE);
|
|
else if (frame_boss==1) dsubimage( lX-3, lY, &bossmages, OFFSET_X_MONSTER+16,54,16,18, DIMAGE_NONE);
|
|
else if (frame_boss==2) dsubimage( lX-5, lY, &bossmages, OFFSET_X_MONSTER+32,54,16,18, DIMAGE_NONE);
|
|
else if (frame_boss==3) dsubimage( lX-8, lY, &bossmages, OFFSET_X_MONSTER,54,16,18, DIMAGE_NONE);
|
|
else if (frame_boss==4) dsubimage( lX-11, lY, &bossmages, OFFSET_X_MONSTER+16,54,16,18, DIMAGE_NONE);
|
|
else if (frame_boss==5) dsubimage( lX-13, lY, &bossmages, OFFSET_X_MONSTER+32,54,16,18, DIMAGE_NONE);
|
|
}
|
|
else if (sens==GAUCHE && BossCollection[k].xcur==mini)
|
|
{
|
|
dsubimage( lX, lY, &bossmages, OFFSET_X_MONSTER,54,16,18, DIMAGE_NONE);
|
|
}
|
|
else if (sens==DROITE && BossCollection[k].xcur<maxi)
|
|
{
|
|
if (frame_boss==0) dsubimage( lX, lY, &bossmages, OFFSET_X_MONSTER,18,16,18, DIMAGE_NONE);
|
|
else if (frame_boss==1) dsubimage( lX+3, lY, &bossmages, OFFSET_X_MONSTER+16,18,16,18, DIMAGE_NONE);
|
|
else if (frame_boss==2) dsubimage( lX+5, lY, &bossmages, OFFSET_X_MONSTER+32,18,16,18, DIMAGE_NONE);
|
|
else if (frame_boss==3) dsubimage( lX+8, lY, &bossmages, OFFSET_X_MONSTER,18,16,18, DIMAGE_NONE);
|
|
else if (frame_boss==4) dsubimage( lX+11, lY, &bossmages, OFFSET_X_MONSTER+16,18,16,18, DIMAGE_NONE);
|
|
else if (frame_boss==5) dsubimage( lX+13, lY, &bossmages, OFFSET_X_MONSTER+32,18,16,18, DIMAGE_NONE);
|
|
}
|
|
else if (sens==DROITE && BossCollection[k].xcur==maxi)
|
|
{
|
|
dsubimage( lX, lY, &bossmages, OFFSET_X_MONSTER,18,16,18, DIMAGE_NONE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
frame_boss++;
|
|
if (frame_boss==6)
|
|
{
|
|
updateBoss();
|
|
frame_boss=0;
|
|
}
|
|
}
|
|
|
|
|
|
void renderReceptors( void )
|
|
{
|
|
for( unsigned char k=0; k<NbReceptorsLevel; k++ )
|
|
{
|
|
unsigned int lX = SIZE*ReceptorCollection[k].x+OFFSET_X+SIZE/2;
|
|
unsigned int lY = SIZE*ReceptorCollection[k].y+OFFSET_Y+SIZE/2;
|
|
unsigned char Rr = ReceptorCollection[k].R;
|
|
unsigned char Gr = ReceptorCollection[k].G;
|
|
unsigned char Br = ReceptorCollection[k].B;
|
|
unsigned int direction = ReceptorCollection[k].direction;
|
|
bool valide = ReceptorCollection[k].isvalide;
|
|
|
|
unsigned char Rc,Gc,Bc;
|
|
|
|
if (valide==false)
|
|
{
|
|
Rc=0;
|
|
Gc=0;
|
|
Bc=0;
|
|
}
|
|
else
|
|
{
|
|
Rc=255;
|
|
Gc=255;
|
|
Bc=255;
|
|
}
|
|
|
|
_boxRGBA( lX-4, lY-4, lX+4, lY+4, Rc, Gc, Bc, 255 );
|
|
_boxRGBA( lX-2, lY-2, lX+2, lY+2, Rr, Gr, Br, 255 );
|
|
|
|
|
|
if (direction==GAUCHE)
|
|
{
|
|
_lineRGBA( lX-4, lY-1, lX-8, lY-1, Rc, Gc, Bc, 255 );
|
|
_lineRGBA( lX-4, lY, lX-8, lY, Rc, Gc, Bc, 255 );
|
|
_lineRGBA( lX-4, lY+1, lX-8, lY+1, Rc, Gc, Bc, 255 );
|
|
}
|
|
else if (direction==DROITE)
|
|
{
|
|
_lineRGBA( lX+4, lY-1, lX+8, lY-1, Rc, Gc, Bc, 255 );
|
|
_lineRGBA( lX+4, lY, lX+8, lY, Rc, Gc, Bc, 255 );
|
|
_lineRGBA( lX+4, lY+1, lX+8, lY+1, Rc, Gc, Bc, 255 );
|
|
}
|
|
else if (direction==HAUT)
|
|
{
|
|
_lineRGBA( lX-1, lY-4, lX-1, lY-8, Rc, Gc, Bc, 255 );
|
|
_lineRGBA( lX, lY-4, lX, lY-8, Rc, Gc, Bc, 255 );
|
|
_lineRGBA( lX+1, lY-4, lX+1, lY-8, Rc, Gc, Bc, 255 );
|
|
}
|
|
else if (direction==BAS)
|
|
{
|
|
_lineRGBA( lX-1, lY+4, lX-1, lY+8, Rc, Gc, Bc, 255 );
|
|
_lineRGBA( lX, lY+4, lX, lY+8, Rc, Gc, Bc, 255 );
|
|
_lineRGBA( lX+1, lY+4, lX+1, lY+8, Rc, Gc, Bc, 255 );
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
void checkReceptors( void )
|
|
{
|
|
for( unsigned char k=0; k<NbReceptorsLevel; k++ )
|
|
{
|
|
unsigned int lX1=0, lX2=0, lX3=0;
|
|
unsigned int lY1=0, lY2=0, lY3=0;
|
|
|
|
unsigned int lX = SIZE*ReceptorCollection[k].x+OFFSET_X+SIZE/2;
|
|
unsigned int lY = SIZE*ReceptorCollection[k].y+OFFSET_Y+SIZE/2;
|
|
unsigned char Rr = ReceptorCollection[k].R;
|
|
unsigned char Gr = ReceptorCollection[k].G;
|
|
unsigned char Br = ReceptorCollection[k].B;
|
|
unsigned int direction = ReceptorCollection[k].direction;
|
|
|
|
if (direction==GAUCHE)
|
|
{
|
|
// all 7 changed to 8
|
|
lX1=lX-7;
|
|
lX2=lX-7;
|
|
lX3=lX-7;
|
|
lY1=lY-1;
|
|
lY2=lY;
|
|
lY3=lY+1;
|
|
}
|
|
else if (direction==DROITE)
|
|
{
|
|
lX1=lX+7;
|
|
lX2=lX+7;
|
|
lX3=lX+7;
|
|
lY1=lY-1;
|
|
lY2=lY;
|
|
lY3=lY+1;
|
|
}
|
|
else if (direction==HAUT)
|
|
{
|
|
lX1=lX-1;
|
|
lX2=lX;
|
|
lX3=lX+1;
|
|
lY1=lY-7;
|
|
lY2=lY-7;
|
|
lY3=lY-7;
|
|
}
|
|
else if (direction==BAS)
|
|
{
|
|
lX1=lX-1;
|
|
lX2=lX;
|
|
lX3=lX+1;
|
|
lY1=lY+7;
|
|
lY2=lY+7;
|
|
lY3=lY+7;
|
|
}
|
|
|
|
unsigned char R1, G1, B1;
|
|
unsigned char R2, G2, B2;
|
|
unsigned char R3, G3, B3;
|
|
unsigned char Rm, Gm, Bm;
|
|
|
|
_getPixelRGB( lX1, lY1, &R1, &G1, &B1 );
|
|
_getPixelRGB( lX2, lY2, &R2, &G2, &B2 );
|
|
_getPixelRGB( lX3, lY3, &R3, &G3, &B3 );
|
|
|
|
Rm = (R1+R2+R3)/3;
|
|
Gm = (G1+G2+G3)/3;
|
|
Bm = (B1+B2+B3)/3;
|
|
|
|
// _boxRGBA( 310, 10+k*30, 330, 30+k*30, Rm, Gm, Bm, 255 );
|
|
// _rectangleRGBA( 310, 10+k*30, 330, 30+k*30, 0, 0, 0, 255 );
|
|
|
|
// _boxRGBA( 340, 10+k*30, 360, 30+k*30, Rr, Gr, Br, 255 );
|
|
// _rectangleRGBA( 340, 10+k*30, 360, 30+k*30, 0, 0, 0, 255 );
|
|
|
|
|
|
if (Rm>=Rr-EPSILON && Rm<=Rr+EPSILON && Gm>=Gr-EPSILON && Gm<=Gr+EPSILON && Bm>=Br-EPSILON && Bm<=Br+EPSILON)
|
|
{
|
|
ReceptorCollection[k].isvalide = true;
|
|
}
|
|
else
|
|
{
|
|
ReceptorCollection[k].isvalide = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
void renderDoors( void )
|
|
{
|
|
for( unsigned char k=0; k<NbDoorsLevel; k++ )
|
|
{
|
|
unsigned int lX = SIZE*DoorCollection[k].x+OFFSET_X;
|
|
unsigned int lY = SIZE*DoorCollection[k].y+OFFSET_Y;
|
|
|
|
int OFFSET_Y_TILE = 16*LEVELCOLOR;
|
|
|
|
if (DoorCollection[k].isdoor==false) // check if it is a door or a wall (draw walls)
|
|
{
|
|
if (DoorCollection[k].direction == HAUT)
|
|
{
|
|
dsubimage( lX, lY, &sprites, 0,OFFSET_Y_TILE+16,16,16, DIMAGE_NONE);
|
|
}
|
|
else if (DoorCollection[k].direction == GAUCHE)
|
|
{
|
|
dsubimage( lX, lY, &sprites, 16,OFFSET_Y_TILE+16,16,16, DIMAGE_NONE);
|
|
}
|
|
else if (DoorCollection[k].direction == BAS)
|
|
{
|
|
dsubimage( lX, lY, &sprites, 32,OFFSET_Y_TILE+16,16,16, DIMAGE_NONE);
|
|
}
|
|
else if (DoorCollection[k].direction == DROITE)
|
|
{
|
|
dsubimage( lX, lY, &sprites, 48,OFFSET_Y_TILE+16,16,16, DIMAGE_NONE);
|
|
}
|
|
}
|
|
else if (DoorCollection[k].isopen==false) // check if the door is open (draw stairs)
|
|
{
|
|
if (DoorCollection[k].direction == HAUT)
|
|
{
|
|
dsubimage( lX, lY, &sprites, 0,80,16,16, DIMAGE_NONE);
|
|
}
|
|
else if (DoorCollection[k].direction == GAUCHE)
|
|
{
|
|
dsubimage( lX, lY, &sprites, 16,80,16,16, DIMAGE_NONE);
|
|
}
|
|
else if (DoorCollection[k].direction == BAS)
|
|
{
|
|
dsubimage( lX, lY, &sprites, 32,80,16,16, DIMAGE_NONE);
|
|
}
|
|
else if (DoorCollection[k].direction == DROITE)
|
|
{
|
|
dsubimage( lX, lY, &sprites, 48,80,16,16, DIMAGE_NONE);
|
|
}
|
|
}
|
|
else // check if the door is open (draw doors)
|
|
{
|
|
if (DoorCollection[k].direction == HAUT)
|
|
{
|
|
dsubimage( lX, lY, &sprites, 0,96,16,16, DIMAGE_NONE);
|
|
}
|
|
else if (DoorCollection[k].direction == GAUCHE)
|
|
{
|
|
dsubimage( lX, lY, &sprites, 16,96,16,16, DIMAGE_NONE);
|
|
}
|
|
else if (DoorCollection[k].direction == BAS)
|
|
{
|
|
dsubimage( lX, lY, &sprites, 32,96,16,16, DIMAGE_NONE);
|
|
}
|
|
else if (DoorCollection[k].direction == DROITE)
|
|
{
|
|
dsubimage( lX, lY, &sprites, 48,96,16,16, DIMAGE_NONE);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void checkDoors( void )
|
|
{
|
|
for( unsigned char k=0; k<NbDoorsLevel; k++ )
|
|
{
|
|
if (DoorCollection[k].isdoor==true) // check if it is a door or a wall
|
|
{
|
|
bool temp = true;
|
|
for(int j=0; j<DoorCollection[k].nbreceptor; j++ )
|
|
{
|
|
int receptorReference = DoorCollection[k].receptors[j];
|
|
bool currentrecept = ReceptorCollection[receptorReference].isvalide;
|
|
Receptor* tempRecept = &ReceptorCollection[receptorReference];
|
|
|
|
temp=temp && currentrecept;
|
|
|
|
if (currentrecept)
|
|
{
|
|
if(DoorCollection[k].direction==HAUT)
|
|
{
|
|
int X = DoorCollection[k].x*SIZE+OFFSET_X;
|
|
int Y = DoorCollection[k].y*SIZE-SIZE/2+OFFSET_Y;
|
|
|
|
if (DoorCollection[k].nbreceptor==1)
|
|
{
|
|
_boxRGBA( X+SIZE/2-1, Y-1, X+SIZE/2+1, Y+1, tempRecept->R, tempRecept->G, tempRecept->B, 255);
|
|
_rectangleRGBA( X+SIZE/2-2, Y-2, X+SIZE/2+2, Y+2, 150, 150, 150, 255);
|
|
}
|
|
else if (DoorCollection[k].nbreceptor==2)
|
|
{
|
|
_boxRGBA( X+SIZE/3*(j+1)-1, Y-1, X+SIZE/3*(j+1)+1, Y+1, tempRecept->R, tempRecept->G, tempRecept->B, 255);
|
|
_rectangleRGBA( X+SIZE/3*(j+1)-2, Y-2, X+SIZE/3*(j+1)+2, Y+2, 150, 150, 150, 255);
|
|
}
|
|
else if (DoorCollection[k].nbreceptor==3)
|
|
{
|
|
_boxRGBA( X+SIZE/4*(j+1)-1, Y-1, X+SIZE/4*(j+1)+1, Y+1, tempRecept->R, tempRecept->G, tempRecept->B, 255);
|
|
_rectangleRGBA( X+SIZE/4*(j+1)-2, Y-2, X+SIZE/4*(j+1)+2, Y+2, 150, 150, 150, 255);
|
|
}
|
|
}
|
|
else if(DoorCollection[k].direction==BAS)
|
|
{
|
|
int X = DoorCollection[k].x*SIZE+OFFSET_X;
|
|
int Y = DoorCollection[k].y*SIZE+3*SIZE/2+OFFSET_Y;
|
|
|
|
if (DoorCollection[k].nbreceptor==1)
|
|
{
|
|
_boxRGBA( X+SIZE/2-1, Y-1, X+SIZE/2+1, Y+1, tempRecept->R, tempRecept->G, tempRecept->B, 255);
|
|
_rectangleRGBA( X+SIZE/2-2, Y-2, X+SIZE/2+2, Y+2, 150, 150, 150, 255);
|
|
}
|
|
else if (DoorCollection[k].nbreceptor==2)
|
|
{
|
|
_boxRGBA( X+SIZE/3*(j+1)-1, Y-1, X+SIZE/3*(j+1)+1, Y+1, tempRecept->R, tempRecept->G, tempRecept->B, 255);
|
|
_rectangleRGBA( X+SIZE/3*(j+1)-2, Y-2, X+SIZE/3*(j+1)+2, Y+2, 150, 150, 150, 255);
|
|
}
|
|
else if (DoorCollection[k].nbreceptor==3)
|
|
{
|
|
_boxRGBA( X+SIZE/4*(j+1)-1, Y-1, X+SIZE/4*(j+1)+1, Y+1, tempRecept->R, tempRecept->G, tempRecept->B, 255);
|
|
_rectangleRGBA( X+SIZE/4*(j+1)-2, Y-2, X+SIZE/4*(j+1)+2, Y+2, 150, 150, 150, 255);
|
|
}
|
|
}
|
|
else if(DoorCollection[k].direction==GAUCHE)
|
|
{
|
|
int X = DoorCollection[k].x*SIZE-SIZE/2+OFFSET_X;
|
|
int Y = DoorCollection[k].y*SIZE+OFFSET_Y;
|
|
|
|
if (DoorCollection[k].nbreceptor==1)
|
|
{
|
|
_boxRGBA( X-1, Y+SIZE/2-1, X+1, Y+SIZE/2+1, tempRecept->R, tempRecept->G, tempRecept->B, 255);
|
|
_rectangleRGBA( X-2, Y+SIZE/2-2, X+2, Y+SIZE/2+2, 150, 150, 150, 255);
|
|
}
|
|
else if (DoorCollection[k].nbreceptor==2)
|
|
{
|
|
_boxRGBA( X-1, Y+SIZE/3*(j+1)-1, X+1, Y+SIZE/3*(j+1)+1, tempRecept->R, tempRecept->G, tempRecept->B, 255);
|
|
_rectangleRGBA( X-2, Y+SIZE/3*(j+1)-2, X+2, Y+SIZE/3*(j+1)+2, 150, 150, 150, 255);
|
|
}
|
|
else if (DoorCollection[k].nbreceptor==3)
|
|
{
|
|
_boxRGBA( X-1, Y+SIZE/4*(j+1)-1, X+1, Y+SIZE/4*(j+1)+1, tempRecept->R, tempRecept->G, tempRecept->B, 255);
|
|
_rectangleRGBA( X-2, Y+SIZE/4*(j+1)-2, X+2, Y+SIZE/4*(j+1)+2, 150, 150, 150, 255);
|
|
}
|
|
}
|
|
else if(DoorCollection[k].direction==DROITE)
|
|
{
|
|
int X = DoorCollection[k].x*SIZE+3*SIZE/2+OFFSET_X;
|
|
int Y = DoorCollection[k].y*SIZE+OFFSET_Y;
|
|
|
|
if (DoorCollection[k].nbreceptor==1)
|
|
{
|
|
_boxRGBA( X-1, Y+SIZE/2-1, X+1, Y+SIZE/2+1, tempRecept->R, tempRecept->G, tempRecept->B, 255);
|
|
_rectangleRGBA( X-2, Y+SIZE/2-2, X+2, Y+SIZE/2+2, 150, 150, 150, 255);
|
|
}
|
|
else if (DoorCollection[k].nbreceptor==2)
|
|
{
|
|
_boxRGBA( X-1, Y+SIZE/3*(j+1)-1, X+1, Y+SIZE/3*(j+1)+1, tempRecept->R, tempRecept->G, tempRecept->B, 255);
|
|
_rectangleRGBA( X-2, Y+SIZE/3*(j+1)-2, X+2, Y+SIZE/3*(j+1)+2, 150, 150, 150, 255);
|
|
}
|
|
else if (DoorCollection[k].nbreceptor==3)
|
|
{
|
|
_boxRGBA( X-1, Y+SIZE/4*(j+1)-1, X+1, Y+SIZE/4*(j+1)+1, tempRecept->R, tempRecept->G, tempRecept->B, 255);
|
|
_rectangleRGBA( X-2, Y+SIZE/4*(j+1)-2, X+2, Y+SIZE/4*(j+1)+2, 150, 150, 150, 255);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
DoorCollection[k].isopen=temp;
|
|
}
|
|
}
|
|
}
|
|
|
|
int my_profile(int key, int duration, int count)
|
|
{
|
|
// key: Key being repeated
|
|
// duration: How long that key has been pressed
|
|
// count: How many times it's been repeated already
|
|
// Return value: how long to wait before next repeat (µs)
|
|
|
|
// Only allow KEY_LEFT and KEY_RIGHT
|
|
if(key != KEY_LEFT && key != KEY_RIGHT)
|
|
return -1;
|
|
|
|
// 500 ms for first repeat, 50 ms after that; stop after 10 repeats
|
|
if(count == 0)
|
|
return 500*1000;
|
|
else
|
|
return 50*1000;
|
|
|
|
/*else if(count < 10)
|
|
return 50*1000;
|
|
else
|
|
return -1;
|
|
*/
|
|
}
|
|
|
|
static int get_inputs_option(void)
|
|
{
|
|
//int opt = GETKEY_DEFAULT & ~GETKEY_REP_ARROWS;
|
|
//int timeout = 1;
|
|
|
|
getkey_set_repeat_profile(my_profile);
|
|
int opt = GETKEY_DEFAULT | GETKEY_REP_PROFILE;
|
|
int timeout = 1;
|
|
//getkey_opt(opt, &timeout);
|
|
|
|
while(1)
|
|
{
|
|
key_event_t ev = getkey_opt(opt, &timeout);
|
|
if(ev.type == KEYEV_NONE) return -1;
|
|
|
|
int key = ev.key;
|
|
|
|
if (key==KEY_EXIT)
|
|
{
|
|
doneOption = true;
|
|
}
|
|
if (key==KEY_UP && selectOptionMenu>0)
|
|
{
|
|
selectOptionMenu--;
|
|
}
|
|
if (key==KEY_DOWN && selectOptionMenu<3)
|
|
{
|
|
selectOptionMenu++;
|
|
}
|
|
if (key==KEY_LEFT && selectOptionMenu==1)
|
|
{
|
|
if (ALPHA_TRANSPARENT>0)
|
|
ALPHA_TRANSPARENT--;
|
|
}
|
|
if (key==KEY_RIGHT && selectOptionMenu==1)
|
|
{
|
|
if (ALPHA_TRANSPARENT<255)
|
|
ALPHA_TRANSPARENT++;
|
|
}
|
|
if (key==KEY_LEFT && selectOptionMenu==2)
|
|
{
|
|
if (ALPHA_OPAQUE>0)
|
|
ALPHA_OPAQUE--;
|
|
}
|
|
if (key==KEY_RIGHT && selectOptionMenu==2)
|
|
{
|
|
if (ALPHA_OPAQUE<255)
|
|
ALPHA_OPAQUE++;
|
|
}
|
|
if (key==KEY_EXE && selectOptionMenu==3)
|
|
{
|
|
ALPHA_OPAQUE = ALPHA_OPAQUE_DEFAULT;
|
|
ALPHA_TRANSPARENT = ALPHA_TRANSPARENT_DEFAULT;
|
|
}
|
|
if (key ==KEY_EXE && selectOptionMenu!=3)
|
|
{
|
|
doneOption = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void drawOption( void )
|
|
{
|
|
doneOption = false;
|
|
|
|
unsigned int lX = 0;
|
|
unsigned int lY = 0;
|
|
|
|
frame_light = 0;
|
|
|
|
while (!doneOption)
|
|
{
|
|
dclear(C_RGB(0,0,0));
|
|
|
|
dimage( 0, 10, &bigparch);
|
|
dimage( 88, 42, &maintitle);
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 90, 95, C_RGB(150,150,150), "Back to Game");
|
|
dprint( 89, 94, C_BLACK, "Back to Game");
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 90, 110, C_RGB(150,150,150), "Adjust Color Alpha");
|
|
dprint( 89, 109, C_BLACK, "Adjust Color Alpha");
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 90, 125, C_RGB(150,150,150), "Adjust Black Alpha");
|
|
dprint( 89, 124, C_BLACK, "Adjust Black Alpha");
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 90, 140, C_RGB(150,150,150), "Set Default Settings");
|
|
dprint( 89, 139, C_BLACK, "Set Default Settings");
|
|
|
|
dfont( &font_tiny );
|
|
|
|
_boxRGBA( 220, 105, 253, 117, 255, 0, 0, ALPHA_TRANSPARENT );
|
|
_boxRGBA( 254, 105, 286, 117, 0, 255, 0, ALPHA_TRANSPARENT );
|
|
_boxRGBA( 287, 105, 320, 117, 0, 0, 255, ALPHA_TRANSPARENT );
|
|
_rectangleRGBA(220, 105, 320, 117, 255, 255, 255, 255);
|
|
|
|
dprint( 265, 107, C_BLACK, "%d", ALPHA_TRANSPARENT);
|
|
|
|
_boxRGBA( 220, 120, 320, 132, 0, 0, 0, ALPHA_OPAQUE );
|
|
_rectangleRGBA(220, 120, 320, 132, 255, 255, 255, 255);
|
|
|
|
dprint( 265, 122, C_WHITE, "%d", ALPHA_OPAQUE);
|
|
|
|
if (selectOptionMenu == 0)
|
|
{
|
|
lX = 70;
|
|
lY = 89;
|
|
}
|
|
else if (selectOptionMenu == 1)
|
|
{
|
|
lX = 70;
|
|
lY = 104;
|
|
}
|
|
else if (selectOptionMenu == 2)
|
|
{
|
|
lX = 70;
|
|
lY = 119;
|
|
}
|
|
else if (selectOptionMenu == 3)
|
|
{
|
|
lX = 70;
|
|
lY = 134;
|
|
}
|
|
|
|
frame_light%=6;
|
|
dsubimage( lX, lY, &light, 16*frame_light,0,16,16, DIMAGE_NONE);
|
|
frame_light++;
|
|
|
|
|
|
dfont( &font_tiny );
|
|
dprint( 90, 160, C_RGB(150,150,150), "[UP] [DOWN] : select / [LEFT] [RIGHT] : adjust");
|
|
dprint( 89, 159, C_BLACK, "[UP] [DOWN] : select / [LEFT] [RIGHT] : adjust");
|
|
dprint( 90, 170, C_RGB(150,150,150), "[EXE] : validate / [EXIT] : escape");
|
|
dprint( 89, 169, C_BLACK,"[EXE] : validate / [EXIT] : escape");
|
|
|
|
dupdate();
|
|
|
|
get_inputs_option();
|
|
}
|
|
}
|
|
|
|
static int get_inputs_quit(void)
|
|
{
|
|
int opt = GETKEY_DEFAULT & ~GETKEY_REP_ARROWS;
|
|
int timeout = 1;
|
|
|
|
while(1)
|
|
{
|
|
key_event_t ev = getkey_opt(opt, &timeout);
|
|
if(ev.type == KEYEV_NONE) return -1;
|
|
|
|
int key = ev.key;
|
|
|
|
if (key==KEY_EXIT)
|
|
{
|
|
donePause = true;
|
|
selectOptionPause = 0;
|
|
}
|
|
if (key==KEY_UP && selectOptionPause>0)
|
|
{
|
|
selectOptionPause--;
|
|
}
|
|
if (key==KEY_DOWN && selectOptionPause<2)
|
|
{
|
|
selectOptionPause++;
|
|
}
|
|
if (key==KEY_EXE)
|
|
{
|
|
donePause = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void drawQuit( void )
|
|
{
|
|
donePause = false;
|
|
|
|
unsigned int lX = 0;
|
|
unsigned int lY = 0;
|
|
|
|
frame_light = 0;
|
|
|
|
while (!donePause)
|
|
{
|
|
dclear(C_RGB(0,0,0));
|
|
|
|
dimage( 0, 10, &bigparch);
|
|
dimage( 88, 42, &maintitle);
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 90, 95, C_RGB(150,150,150), "Game Currently in Pause Mode");
|
|
dprint( 89, 94, C_BLACK, "Game Currently in Pause Mode");
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 90, 105, C_RGB(150,150,150), "Are You Sure You Want To Leave ?");
|
|
dprint( 89, 104, C_BLACK, "Are You Sure You Want To Leave ?");
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 90, 125, C_RGB(150,150,150), "No - Get Me Back To Game");
|
|
dprint( 89, 124, C_BLACK, "No - Get Me Back To Game");
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 90, 140, C_RGB(150,150,150), "Yes - For Now, But I'll Come Back !");
|
|
dprint( 89, 139, C_BLACK, "Yes - For Now, But I'll Come Back !");
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 90, 155, C_RGB(150,150,150), "Please, Send Me Back to Main Menu");
|
|
dprint( 89, 154, C_BLACK, "Please, Send Me Back to Main Menu");
|
|
|
|
|
|
dfont( &font_tiny );
|
|
|
|
if (selectOptionPause == 0)
|
|
{
|
|
lX = 70;
|
|
lY = 119;
|
|
GotoMainMenu=false;
|
|
}
|
|
else if (selectOptionPause == 1)
|
|
{
|
|
lX = 70;
|
|
lY = 134;
|
|
GotoMainMenu=false;
|
|
}
|
|
else if (selectOptionPause == 2)
|
|
{
|
|
lX = 70;
|
|
lY = 149;
|
|
GotoMainMenu=true;
|
|
}
|
|
|
|
frame_light%=6;
|
|
dsubimage( lX, lY, &light, 16*frame_light,0,16,16, DIMAGE_NONE);
|
|
frame_light++;
|
|
|
|
dfont( &font_tiny );
|
|
dprint( 55, 170, C_RGB(150,150,150), "[UP] [DOWN] : select / [EXE] : validate / [EXIT] : escape");
|
|
dprint( 54, 169, C_BLACK,"[UP] [DOWN] : select / [EXE] : validate / [EXIT] : escape");
|
|
|
|
dupdate();
|
|
|
|
get_inputs_quit();
|
|
|
|
}
|
|
}
|
|
|
|
static int get_inputs_loose(void)
|
|
{
|
|
int opt = GETKEY_DEFAULT & ~GETKEY_REP_ARROWS;
|
|
int timeout = 1;
|
|
|
|
while(1)
|
|
{
|
|
key_event_t ev = getkey_opt(opt, &timeout);
|
|
if(ev.type == KEYEV_NONE) return -1;
|
|
|
|
int key = ev.key;
|
|
|
|
if (key==KEY_EXIT)
|
|
{
|
|
doneLoose = true;
|
|
selectOptionLoose = 1;
|
|
}
|
|
if (key==KEY_UP && selectOptionLoose>0)
|
|
{
|
|
selectOptionLoose--;
|
|
}
|
|
if (key==KEY_DOWN && selectOptionLoose<1)
|
|
{
|
|
selectOptionLoose++;
|
|
}
|
|
if (key==KEY_EXE)
|
|
{
|
|
doneLoose = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void drawLoose( void )
|
|
{
|
|
doneLoose = false;
|
|
|
|
unsigned int lX = 0;
|
|
unsigned int lY = 0;
|
|
|
|
frame_light = 0;
|
|
|
|
while (!doneLoose)
|
|
{
|
|
dclear(C_RGB(0,0,0));
|
|
|
|
dimage( 0, 10, &bigparch);
|
|
dimage( 88, 42, &maintitle);
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 90, 95, C_RGB(150,150,150), "You Loose : Be Careful Of the Monsters" );
|
|
dprint( 89, 94, C_BLACK, "You Loose : Be Careful Of the Monsters" );
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 90, 105, C_RGB(150,150,150), "RetryThis Level ?" );
|
|
dprint( 89, 104, C_BLACK, "RetryThis Level ?" );
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 90, 125, C_RGB(150,150,150), "Yes - I Never Give Up !!!");
|
|
dprint( 89, 124, C_BLACK, "Yes - I Never Give Up !!!");
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 90, 140, C_RGB(150,150,150), "No - Better If I Quit !!! ");
|
|
dprint( 89, 139, C_BLACK, "No - Better If I Quit !!! ");
|
|
|
|
dfont( &font_tiny );
|
|
|
|
if (selectOptionLoose == 0)
|
|
{
|
|
lX = 70;
|
|
lY = 119;
|
|
}
|
|
else if (selectOptionLoose == 1)
|
|
{
|
|
lX = 70;
|
|
lY = 134;
|
|
}
|
|
|
|
frame_light%=6;
|
|
dsubimage( lX, lY, &light, 16*frame_light,0,16,16, DIMAGE_NONE);
|
|
frame_light++;
|
|
|
|
dfont( &font_tiny );
|
|
dprint( 55, 170, C_RGB(150,150,150), "[UP] [DOWN] : select / [EXE] : validate / [EXIT] : escape");
|
|
dprint( 54, 169, C_BLACK,"[UP] [DOWN] : select / [EXE] : validate / [EXIT] : escape");
|
|
|
|
dupdate();
|
|
|
|
get_inputs_loose();
|
|
|
|
}
|
|
}
|
|
|
|
static int get_inputs_title(void)
|
|
{
|
|
int opt = GETKEY_DEFAULT & ~GETKEY_REP_ARROWS;
|
|
int timeout = 1;
|
|
|
|
while(1)
|
|
{
|
|
key_event_t ev = getkey_opt(opt, &timeout);
|
|
if(ev.type == KEYEV_NONE) return -1;
|
|
|
|
int key = ev.key;
|
|
|
|
if (key==KEY_EXE)
|
|
doneTitle = true;
|
|
}
|
|
}
|
|
|
|
void drawTitle( void )
|
|
{
|
|
doneTitle = false;
|
|
|
|
unsigned int positionGuy = 75;
|
|
int dir = 1;
|
|
|
|
frame = 0;
|
|
unsigned char flickers = 0;
|
|
|
|
while (!doneTitle)
|
|
{
|
|
dclear(C_RGB(0,0,0));
|
|
|
|
dimage( 0, 10, &bigparch);
|
|
dimage( 88, 42, &maintitle);
|
|
|
|
if (dir==1) // the guy is going to the right
|
|
{
|
|
if (positionGuy>=285) dir=-1;
|
|
|
|
if (frame==0) dsubimage( positionGuy, 100, &player, 0,16,16,16, DIMAGE_NONE);
|
|
else if (frame==1) dsubimage( positionGuy, 100, &player, 16,16,16,16, DIMAGE_NONE);
|
|
else if (frame==2) dsubimage( positionGuy, 100, &player, 32,16,16,16, DIMAGE_NONE);
|
|
|
|
frame++;
|
|
positionGuy+=1;
|
|
if (frame==3) frame=0;
|
|
}
|
|
else if (dir==-1) // the guy is going to the left
|
|
{
|
|
if (positionGuy<=75) dir=1;
|
|
|
|
if (frame==0) dsubimage( positionGuy, 100, &player, 0,48,16,16, DIMAGE_NONE);
|
|
else if (frame==1) dsubimage( positionGuy, 100, &player, 16,48,16,16, DIMAGE_NONE);
|
|
else if (frame==2) dsubimage( positionGuy, 100, &player, 32,48,16,16, DIMAGE_NONE);
|
|
|
|
frame++;
|
|
positionGuy-=1;
|
|
if (frame==3) frame=0;
|
|
}
|
|
|
|
if (flickers<20)
|
|
{
|
|
dfont( &font_fantasy );
|
|
dprint( 120, 130, C_RGB(150,150,150), "[ Press EXE Key To Start ]");
|
|
dprint( 119, 129, C_BLACK, "[ Press EXE Key To Start ]");
|
|
}
|
|
|
|
dfont( &font_tiny );
|
|
dprint( 110, 156, C_RGB(150,150,150), "Welcome to Magic Light %s", Revision);
|
|
dprint( 109, 155, C_BLACK, "Welcome to Magic Light %s", Revision);
|
|
dprint( 110, 166, C_RGB(150,150,150), " 12/2021 - by SlyVTT ");
|
|
dprint( 109, 165, C_BLACK, " 12/2021 - by SlyVTT ");
|
|
|
|
|
|
flickers++;
|
|
if (flickers==40) flickers=0;
|
|
|
|
dupdate();
|
|
|
|
get_inputs_title();
|
|
}
|
|
}
|
|
|
|
static int get_inputs_difficultymenu(void)
|
|
{
|
|
int opt = GETKEY_DEFAULT & ~GETKEY_REP_ARROWS;
|
|
int timeout = 1;
|
|
|
|
while(1)
|
|
{
|
|
key_event_t ev = getkey_opt(opt, &timeout);
|
|
if(ev.type == KEYEV_NONE) return -1;
|
|
|
|
int key = ev.key;
|
|
|
|
if (key==KEY_EXE)
|
|
doneDifficulty = true;
|
|
|
|
if (key==KEY_UP && selectStartMenu>0)
|
|
selectDifficultyMenu--;
|
|
|
|
if (key==KEY_DOWN && selectStartMenu<2)
|
|
selectDifficultyMenu++;
|
|
}
|
|
}
|
|
|
|
unsigned char drawDifficultyMenu( void )
|
|
{
|
|
doneDifficulty = false;
|
|
|
|
unsigned int lX = 0;
|
|
unsigned int lY = 0;
|
|
|
|
frame_light = 0;
|
|
|
|
while (!doneDifficulty)
|
|
{
|
|
|
|
dclear(C_RGB(0,0,0));
|
|
|
|
dimage( 0, 10, &bigparch);
|
|
dimage( 88, 42, &maintitle);
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 90, 100, C_RGB(150,150,150), "Sweet Like a Cherry Cake");
|
|
dprint( 89, 99, C_BLACK, "Sweet Like a Cherry Cake");
|
|
|
|
for( unsigned char k = 0; k< 5; k++)
|
|
{
|
|
dsubimage( 250 + k*8, 100, &hearts, 8, 0, 8, 8, DIMAGE_NONE);
|
|
}
|
|
for( unsigned char k = 5; k< 5; k++)
|
|
{
|
|
dsubimage( 250 + k*8, 100, &hearts, 0, 0, 8, 8, DIMAGE_NONE);
|
|
}
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 90, 120, C_RGB(150,150,150), "Acid Like an Orange Juice");
|
|
dprint( 89, 119, C_BLACK, "Acid Like an Orange Juice");
|
|
|
|
for( unsigned char k = 0; k< 3; k++)
|
|
{
|
|
dsubimage( 250 + k*8, 120, &hearts, 8, 0, 8, 8, DIMAGE_NONE);
|
|
}
|
|
for( unsigned char k = 3; k< 5; k++)
|
|
{
|
|
dsubimage( 250 + k*8, 120, &hearts, 0, 0, 8, 8, DIMAGE_NONE);
|
|
}
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 90, 140, C_RGB(150,150,150), "Bitter Like a Dark Beer");
|
|
dprint( 89, 139, C_BLACK, "Bitter Like a Dark Beer");
|
|
|
|
for( unsigned char k = 0; k< 1; k++)
|
|
{
|
|
dsubimage( 250 + k*8, 140, &hearts, 8, 0, 8, 8, DIMAGE_NONE);
|
|
}
|
|
for( unsigned char k = 1; k< 5; k++)
|
|
{
|
|
dsubimage( 250 + k*8, 140, &hearts, 0, 0, 8, 8, DIMAGE_NONE);
|
|
}
|
|
|
|
|
|
if (selectDifficultyMenu == 0)
|
|
{
|
|
lX = 70;
|
|
lY = 94;
|
|
}
|
|
else if (selectDifficultyMenu == 1)
|
|
{
|
|
lX = 70;
|
|
lY = 114;
|
|
}
|
|
else if (selectDifficultyMenu == 2)
|
|
{
|
|
lX = 70;
|
|
lY = 134;
|
|
}
|
|
|
|
frame_light%=6;
|
|
dsubimage( lX, lY, &light, 16*frame_light,0,16,16, DIMAGE_NONE);
|
|
frame_light++;
|
|
|
|
|
|
dfont( &font_tiny );
|
|
dprint( 90, 166, C_RGB(150,150,150), "[UP] [DOWN] : select / [EXE] : validate");
|
|
dprint( 89, 165, C_BLACK,"[UP] [DOWN] : select / [EXE] : validate");
|
|
|
|
dupdate();
|
|
|
|
get_inputs_difficultymenu();
|
|
}
|
|
|
|
return selectDifficultyMenu;
|
|
}
|
|
|
|
static int get_inputs_startmenu(void)
|
|
{
|
|
int opt = GETKEY_DEFAULT & ~GETKEY_REP_ARROWS;
|
|
int timeout = 1;
|
|
|
|
while(1)
|
|
{
|
|
key_event_t ev = getkey_opt(opt, &timeout);
|
|
if(ev.type == KEYEV_NONE) return -1;
|
|
|
|
int key = ev.key;
|
|
|
|
if (key==KEY_EXE)
|
|
doneStart = true;
|
|
|
|
if (saveexist==false && key==KEY_UP && selectStartMenu>1)
|
|
selectStartMenu--;
|
|
|
|
if (saveexist==true && key==KEY_UP && selectStartMenu>0)
|
|
selectStartMenu--;
|
|
|
|
if (key==KEY_DOWN && selectStartMenu<2)
|
|
selectStartMenu++;
|
|
}
|
|
}
|
|
|
|
unsigned char drawStartMenu( void )
|
|
{
|
|
doneStart = false;
|
|
|
|
unsigned int lX = 0;
|
|
unsigned int lY = 0;
|
|
|
|
frame_light = 0;
|
|
|
|
saveexist = false;
|
|
|
|
gint_world_switch( GINT_CALL( is_save_existing ) );
|
|
|
|
if (saveexist==false) selectStartMenu = 1;
|
|
else selectStartMenu = 0;
|
|
|
|
while (!doneStart)
|
|
{
|
|
dclear(C_RGB(0,0,0));
|
|
|
|
dimage( 0, 10, &bigparch);
|
|
dimage( 88, 42, &maintitle);
|
|
|
|
if (saveexist==false)
|
|
{
|
|
dfont( &font_fantasy );
|
|
dprint( 80, 100, C_RGB(150,150,150), "Continue Previous Game");
|
|
dprint( 79, 99, C_RGB(240,240,240), "Continue Previous Game");
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 80, 120, C_RGB(150,150,150), "Start New Game");
|
|
dprint( 79, 119, C_BLACK, "Start New Game");
|
|
}
|
|
else
|
|
{
|
|
dfont( &font_fantasy );
|
|
dprint( 80, 100, C_RGB(150,150,150), "Continue Previous Game");
|
|
dprint( 79, 99, C_BLACK, "Continue Previous Game");
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 80, 120, C_RGB(150,150,150), "Start New Game (Will Trash Previous Save)");
|
|
dprint( 79, 119, C_RED, "Start New Game (Will Trash Previous Save)");
|
|
}
|
|
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 80, 140, C_RGB(150,150,150), "Quit And Back To OS");
|
|
dprint( 79, 139, C_BLACK, "Quit And Back To OS");
|
|
|
|
if (selectStartMenu == 0)
|
|
{
|
|
lX = 60;
|
|
lY = 94;
|
|
}
|
|
else if (selectStartMenu == 1)
|
|
{
|
|
lX = 60;
|
|
lY = 114;
|
|
}
|
|
else if (selectStartMenu == 2)
|
|
{
|
|
lX = 60;
|
|
lY = 134;
|
|
}
|
|
|
|
frame_light%=6;
|
|
dsubimage( lX, lY, &light, 16*frame_light,0,16,16, DIMAGE_NONE);
|
|
frame_light++;
|
|
|
|
|
|
dfont( &font_tiny );
|
|
dprint( 90, 166, C_RGB(150,150,150), "[UP] [DOWN] : select / [EXE] : validate");
|
|
dprint( 89, 165, C_BLACK,"[UP] [DOWN] : select / [EXE] : validate");
|
|
|
|
dupdate();
|
|
|
|
get_inputs_startmenu();
|
|
}
|
|
|
|
return selectStartMenu;
|
|
}
|
|
|
|
|
|
|
|
static int get_inputs_story(void)
|
|
{
|
|
int opt = GETKEY_DEFAULT & ~GETKEY_REP_ARROWS;
|
|
int timeout = 1;
|
|
|
|
while(1)
|
|
{
|
|
key_event_t ev = getkey_opt(opt, &timeout);
|
|
if(ev.type == KEYEV_NONE) return -1;
|
|
|
|
int key = ev.key;
|
|
|
|
if (key==KEY_EXE || key==KEY_EXIT)
|
|
doneStory = true;
|
|
|
|
if (key==KEY_UP && selectStoryMenu>1)
|
|
selectStoryMenu--;
|
|
|
|
if (key==KEY_DOWN && selectStoryMenu<2)
|
|
selectStoryMenu++;
|
|
}
|
|
}
|
|
|
|
void drawStoryMenu( void )
|
|
{
|
|
|
|
doneStory = false;
|
|
|
|
selectStoryMenu = 1;
|
|
|
|
while (!doneStory)
|
|
{
|
|
dclear(C_RGB(0,0,0));
|
|
|
|
dimage( 0, 10, &bigparch);
|
|
dimage( 63, 41, &village);
|
|
|
|
|
|
dfont( &font_tiny );
|
|
dprint( 60, 170, C_RGB(150,150,150), "[EXE/EXIT] >>>");
|
|
dprint( 59, 169, C_BLACK,"[EXE/EXIT] >>>");
|
|
|
|
dupdate();
|
|
|
|
get_inputs_story();
|
|
}
|
|
|
|
doneStory = false;
|
|
selectStoryMenu = 1;
|
|
|
|
while (!doneStory)
|
|
{
|
|
dclear(C_RGB(0,0,0));
|
|
|
|
dimage( 0, 10, &bigparch);
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 70, 55, C_RGB(150,150,150), "A long time ago, in a peaceful and colorful ");
|
|
dprint( 69, 54, C_BLACK, "A long time ago, in a peaceful and colorful");
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 55, 75, C_RGB(150,150,150), "village came a Dark Sorcerer with the terrible");
|
|
dprint( 54, 74, C_BLACK, "village came a Dark Sorcerer with the terrible");
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 55, 95, C_RGB(150,150,150), "ambition of stealing all lights and colors. Making" );
|
|
dprint( 54, 94, C_BLACK, "ambition of stealing all lights and colors. Making " );
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 60, 115, C_RGB(150,150,150), "darkness and fear the only remaining things " );
|
|
dprint( 59, 114, C_BLACK, "darkness and fear the only remaining things" );
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 60, 135, C_RGB(150,150,150), "here ..." );
|
|
dprint( 59, 134, C_BLACK, "here ..." );
|
|
|
|
|
|
|
|
dfont( &font_tiny );
|
|
dprint( 70, 166, C_RGB(150,150,150), "[EXE/EXIT] >>>");
|
|
dprint( 69, 165, C_BLACK,"[EXE/EXIT] >>>");
|
|
|
|
dupdate();
|
|
|
|
get_inputs_story();
|
|
}
|
|
|
|
doneStory = false;
|
|
|
|
selectStoryMenu = 1;
|
|
|
|
/* while (!doneStory)
|
|
{
|
|
dclear(C_RGB(0,0,0));
|
|
|
|
dimage( 0, 10, &bigparch);
|
|
dimage( 63, 41, &village);
|
|
|
|
|
|
dfont( &font_tiny );
|
|
dprint( 60, 170, C_RGB(150,150,150), "[EXE/EXIT] >>>");
|
|
dprint( 59, 169, C_BLACK,"[EXE/EXIT] >>>");
|
|
|
|
dupdate();
|
|
|
|
get_inputs_story();
|
|
}
|
|
*/
|
|
|
|
int nbstep = 128;
|
|
|
|
memcpy( palette, village.data, 512 );
|
|
uint16_t paletteNB[256];
|
|
uint16_t paletteTemp[256];
|
|
|
|
uint16_t paletteStart[256][3];
|
|
uint16_t paletteEnd[256][3];
|
|
uint16_t paletteNow[256][3];
|
|
int16_t paletteDelta[256][3];
|
|
|
|
for( int k=0; k<255; k++)
|
|
{
|
|
unsigned char B=(unsigned char) ((palette[k] & 0b0000000000011111)<<3);
|
|
unsigned char G=(unsigned char) (((palette[k] & 0b0000011111100000) >> 5)<<2);
|
|
unsigned char R=(unsigned char) (((palette[k] & 0b1111100000000000) >> 11)<<3);
|
|
|
|
paletteStart[k][0] = R<<8;
|
|
paletteStart[k][1] = G<<8;
|
|
paletteStart[k][2] = B<<8;
|
|
|
|
uint16_t Moy = (0.299*R+0.587*G+0.114*B);
|
|
|
|
paletteEnd[k][0] = Moy<<8;
|
|
paletteEnd[k][1] = Moy<<8;
|
|
paletteEnd[k][2] = Moy<<8;
|
|
|
|
paletteDelta[k][0] = (paletteEnd[k][0] - paletteStart[k][0])/nbstep;
|
|
paletteDelta[k][1] = (paletteEnd[k][1] - paletteStart[k][1])/nbstep;
|
|
paletteDelta[k][2] = (paletteEnd[k][2] - paletteStart[k][2])/nbstep;
|
|
|
|
paletteNB[k] = (uint16_t) (((Moy>>3) << 11) | ((Moy>>2) << 5 ) | (Moy>>3));
|
|
}
|
|
//memcpy( village.data, paletteNB, 512 );
|
|
|
|
|
|
int framevillage = 0;
|
|
doneStory = false;
|
|
|
|
|
|
while (!doneStory)
|
|
{
|
|
dclear(C_RGB(0,0,0));
|
|
|
|
dimage( 0, 10, &bigparch);
|
|
|
|
if (framevillage<=nbstep)
|
|
{
|
|
for( int k=0; k<255; k++)
|
|
{
|
|
paletteNow[k][0] = (paletteStart[k][0]+framevillage*paletteDelta[k][0])>>8;
|
|
paletteNow[k][1] = (paletteStart[k][1]+framevillage*paletteDelta[k][1])>>8;
|
|
paletteNow[k][2] = (paletteStart[k][2]+framevillage*paletteDelta[k][2])>>8;
|
|
paletteTemp[k] = (uint16_t) (((paletteNow[k][0]>>3) << 11) | ((paletteNow[k][1]>>2) << 5 ) | (paletteNow[k][2]>>3));
|
|
}
|
|
memcpy( village.data, paletteTemp, 512 );
|
|
}
|
|
else
|
|
{
|
|
memcpy( village.data, paletteNB, 512 );
|
|
}
|
|
|
|
framevillage++;
|
|
if (framevillage>=nbstep) framevillage=nbstep;
|
|
|
|
dimage( 63, 41, &village);
|
|
|
|
|
|
dfont( &font_tiny );
|
|
dprint( 60, 170, C_RGB(150,150,150), "[EXE/EXIT] >>>");
|
|
dprint( 59, 169, C_BLACK,"[EXE/EXIT] >>>");
|
|
|
|
dupdate();
|
|
|
|
get_inputs_story();
|
|
}
|
|
|
|
doneStory = false;
|
|
selectStoryMenu = 1;
|
|
|
|
while (!doneStory)
|
|
{
|
|
dclear(C_RGB(0,0,0));
|
|
|
|
dimage( 0, 10, &bigparch);
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 60, 55, C_RGB(150,150,150), "The Sorcerer returned to his Castle" );
|
|
dprint( 59, 54, C_BLACK, "The Sorcerer returned to his Castle" );
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 60, 75, C_RGB(150,150,150), "and ruled his Daughters to protect his loot..." );
|
|
dprint( 59, 74, C_BLACK, "and ruled his Daughters to protect his loot..." );
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 65, 95, C_RGB(150,150,150), "Guided only by courage, you entered the" );
|
|
dprint( 64, 94, C_BLACK, "Guided only by courage, you entered the" );
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 65, 115, C_RGB(150,150,150), "castle to defeat all dangers and help the" );
|
|
dprint( 64, 114, C_BLACK, "castle to defeat all dangers and help the" );
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 65, 135, C_RGB(150,150,150), "villagers ... Good luck my Friend !!!" );
|
|
dprint( 64, 134, C_BLACK, "villagers ... Good luck my Friend !!!" );
|
|
|
|
|
|
dfont( &font_tiny );
|
|
dprint( 60, 170, C_RGB(150,150,150), "[EXE/EXIT] >>>");
|
|
dprint( 59, 169, C_BLACK,"[EXE/EXIT] >>>");
|
|
|
|
dupdate();
|
|
|
|
get_inputs_story();
|
|
}
|
|
|
|
doneStory = false;
|
|
|
|
selectStoryMenu = 1;
|
|
|
|
|
|
while (!doneStory)
|
|
{
|
|
dclear(C_RGB(0,0,0));
|
|
|
|
dimage( 0, 10, &bigparch);
|
|
dimage( 63, 41, &castletitle);
|
|
|
|
|
|
dfont( &font_tiny );
|
|
dprint( 60, 170, C_RGB(150,150,150), "[EXE/EXIT] Play");
|
|
dprint( 59, 169, C_BLACK,"[EXE/EXIT] Play");
|
|
|
|
dupdate();
|
|
|
|
get_inputs_story();
|
|
}
|
|
|
|
memcpy( village.data, palette, 512 );
|
|
}
|
|
|
|
|
|
|
|
void updateTreasures( selection what )
|
|
{
|
|
if (what==JOUEUR)
|
|
{
|
|
unsigned char X = joueur.x;
|
|
unsigned char Y= joueur.y;
|
|
|
|
for (unsigned char k=0; k<NbTreasureLevel; k++)
|
|
{
|
|
if (X==TreasureCollection[k].x && Y==TreasureCollection[k].y)
|
|
{
|
|
if (TreasureCollection[k].isopen==false)
|
|
{
|
|
score+=TreasureCollection[k].scoreboost;
|
|
TreasureCollection[k].isopen=true;
|
|
|
|
if (TreasureCollection[k].inside == BLACK_FRAGMENT) BlackFrag=true;
|
|
if (TreasureCollection[k].inside == WHITE_FRAGMENT) WhiteFrag=true;
|
|
if (TreasureCollection[k].inside == RED_FRAGMENT) RedFrag=true;
|
|
if (TreasureCollection[k].inside == GREEN_FRAGMENT) GreenFrag=true;
|
|
if (TreasureCollection[k].inside == BLUE_FRAGMENT) BlueFrag=true;
|
|
|
|
if (TreasureCollection[k].inside == HEART_SINGLE)
|
|
{
|
|
if (difficulty==0 && life<5) life++;
|
|
else if (difficulty==1 && life<3) life++;
|
|
else if (difficulty==2 && life<1) life++; // this is just theorical as Life < 1 means that you loose !!
|
|
}
|
|
|
|
if (TreasureCollection[k].inside == HEART_FULL)
|
|
{
|
|
if (difficulty==0) life=5;
|
|
else if (difficulty==1) life=3;
|
|
else if (difficulty==2) life=1; // this is just theorical as Life < 1 means that you loose !!
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
TreasureCollection[k].isvisible=false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void launch_Boss_Attack( void )
|
|
{
|
|
|
|
if (frame_boss_attack==0)
|
|
{
|
|
attackboss=true;
|
|
xbossattack=BossCollection[0].xcur*SIZE+OFFSET_X+SIZE/2;
|
|
ybossattack=BossCollection[0].ycur*SIZE+OFFSET_Y+SIZE/2;
|
|
|
|
srand( rtc_ticks() );
|
|
attacktype = rand() % 8;
|
|
attackpattern = rand() % 2;
|
|
|
|
if (attacktype==0) NbBulletLevel=5;
|
|
else if (attacktype==1) NbBulletLevel=10;
|
|
else if (attacktype==2) NbBulletLevel=20;
|
|
else if (attacktype==3) NbBulletLevel=10;
|
|
else if (attacktype==4) NbBulletLevel=20;
|
|
else if (attacktype==5) NbBulletLevel=10;
|
|
else if (attacktype==6) NbBulletLevel=20;
|
|
else NbBulletLevel=40;
|
|
|
|
free( BulletCollection );
|
|
BulletCollection = (Bullet*) malloc( NbBulletLevel * sizeof( Bullet ) );
|
|
|
|
for( unsigned char k = 0; k<NbBulletLevel; k++)
|
|
{
|
|
BulletCollection[k].visible = true;
|
|
}
|
|
|
|
}
|
|
|
|
if ( attackpattern == 0)
|
|
{
|
|
for( unsigned char k=0; k<NbBulletLevel; k++)
|
|
{
|
|
if ( BulletCollection[k].visible == true )
|
|
{
|
|
int xpart = xbossattack + 2*frame_boss_attack*cos( k*360/NbBulletLevel*3.1415927/180.0 );
|
|
int ypart = ybossattack + 2*frame_boss_attack*sin( k*360/NbBulletLevel*3.1415927/180.0 );
|
|
|
|
unsigned char cellX = (xpart-OFFSET_X)/SIZE;
|
|
unsigned char cellY = (ypart-OFFSET_Y)/SIZE;
|
|
|
|
for (unsigned char j = 0; j<NbObstacleLevel; j++)
|
|
{
|
|
if (ObstaclesCollection[j].x==cellX && ObstaclesCollection[j].y==cellY && ObstaclesCollection[j].type!=BLOCK_WATER)
|
|
{
|
|
BulletCollection[k].visible = false;
|
|
}
|
|
}
|
|
for (unsigned char j = 0; j<NbBlocksLevel; j++)
|
|
{
|
|
if (BlocksCollection[j].x==cellX && BlocksCollection[j].y==cellY)
|
|
{
|
|
BulletCollection[k].visible = false;
|
|
}
|
|
}
|
|
if (cellX==joueur.x && cellY==joueur.y)
|
|
{
|
|
if (life>0) life--;
|
|
BulletCollection[k].visible = false;
|
|
}
|
|
|
|
if (xpart<OFFSET_X+SIZE || xpart>OFFSET_X+SIZE*(SIZE_MAP_X-1) || ypart <OFFSET_Y+SIZE || ypart>OFFSET_Y+SIZE*(SIZE_MAP_Y-1))
|
|
{
|
|
BulletCollection[k].visible = false;
|
|
}
|
|
|
|
|
|
if ( BulletCollection[k].visible == true ) dsubimage( xpart-8, ypart-8, &bulletsbicolor, frame_bullet*16,attacktype*16,16,16, DIMAGE_NONE);
|
|
}
|
|
|
|
}
|
|
}
|
|
else if ( attackpattern == 1)
|
|
{
|
|
for( unsigned char k=0; k<NbBulletLevel; k++)
|
|
{
|
|
if ( BulletCollection[k].visible == true )
|
|
{
|
|
int xpart = xbossattack + 2*frame_boss_attack*cos( (frame_boss_attack*2+k*360/NbBulletLevel)*3.1415927/180.0 );
|
|
int ypart = ybossattack + 2*frame_boss_attack*sin( (frame_boss_attack*2+k*360/NbBulletLevel)*3.1415927/180.0 );
|
|
|
|
unsigned char cellX = (xpart-OFFSET_X)/SIZE;
|
|
unsigned char cellY = (ypart-OFFSET_Y)/SIZE;
|
|
|
|
for (unsigned char j = 0; j<NbObstacleLevel; j++)
|
|
{
|
|
if (ObstaclesCollection[j].x==cellX && ObstaclesCollection[j].y==cellY && ObstaclesCollection[j].type!=BLOCK_WATER)
|
|
{
|
|
BulletCollection[k].visible = false;
|
|
}
|
|
}
|
|
for (unsigned char j = 0; j<NbBlocksLevel; j++)
|
|
{
|
|
if (BlocksCollection[j].x==cellX && BlocksCollection[j].y==cellY)
|
|
{
|
|
BulletCollection[k].visible = false;
|
|
}
|
|
}
|
|
if (cellX==joueur.x && cellY==joueur.y)
|
|
{
|
|
if (life>0) life--;
|
|
BulletCollection[k].visible = false;
|
|
}
|
|
|
|
if (xpart<OFFSET_X+SIZE || xpart>OFFSET_X+SIZE*(SIZE_MAP_X-1) || ypart <OFFSET_Y+SIZE || ypart>OFFSET_Y+SIZE*(SIZE_MAP_Y-1))
|
|
{
|
|
BulletCollection[k].visible = false;
|
|
}
|
|
|
|
|
|
if ( BulletCollection[k].visible == true ) dsubimage( xpart-8, ypart-8, &bulletsbicolor, frame_bullet*16,attacktype*16,16,16, DIMAGE_NONE);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
frame_bullet++;
|
|
if (frame_bullet==8) frame_bullet=0;
|
|
|
|
frame_boss_attack++;
|
|
if (frame_boss_attack==100)
|
|
{
|
|
frame_boss_attack=0;
|
|
attackboss=false;
|
|
free( BulletCollection );
|
|
BulletCollection=NULL;
|
|
}
|
|
}
|
|
|
|
static int get_inputs(void)
|
|
{
|
|
int opt = GETKEY_DEFAULT & ~GETKEY_REP_ARROWS & ~GETKEY_MOD_SHIFT & ~GETKEY_MOD_ALPHA;
|
|
int timeout = 1;
|
|
unsigned char choice_exit=0;
|
|
|
|
while(1)
|
|
{
|
|
key_event_t ev = getkey_opt(opt, &timeout);
|
|
if(ev.type == KEYEV_NONE) return -1;
|
|
|
|
int key = ev.key;
|
|
|
|
if (key==KEY_EXIT)
|
|
{
|
|
drawQuit();
|
|
}
|
|
|
|
if (key==KEY_OPTN)
|
|
{
|
|
drawOption();
|
|
}
|
|
|
|
if (key==KEY_F1)
|
|
{
|
|
selected = JOUEUR;
|
|
}
|
|
|
|
if (key==KEY_F2)
|
|
{
|
|
selected = LUMIERE;
|
|
}
|
|
|
|
if (key==KEY_F3)
|
|
{
|
|
selected = ROUGE;
|
|
}
|
|
|
|
if (key==KEY_F4)
|
|
{
|
|
selected = VERT;
|
|
}
|
|
|
|
if (key==KEY_F5)
|
|
{
|
|
selected = BLEU;
|
|
}
|
|
|
|
if (key==KEY_F6)
|
|
{
|
|
selected = NOIR;
|
|
}
|
|
|
|
if (key==KEY_LEFT)
|
|
{
|
|
gameMechanics( selected, GAUCHE);
|
|
}
|
|
|
|
if (key==KEY_RIGHT)
|
|
{
|
|
gameMechanics( selected, DROITE);
|
|
}
|
|
|
|
if (key==KEY_UP)
|
|
{
|
|
gameMechanics( selected, HAUT);
|
|
}
|
|
|
|
if (key==KEY_DOWN)
|
|
{
|
|
gameMechanics( selected, BAS);
|
|
}
|
|
|
|
if (key==KEY_SHIFT)
|
|
{
|
|
updateTreasures( selected );
|
|
}
|
|
|
|
#if DEBUG==1
|
|
if (key==KEY_1)
|
|
{
|
|
if (currentLevel>0)
|
|
loadLevel(currentLevel-1);
|
|
}
|
|
|
|
if (key==KEY_7)
|
|
{
|
|
if (currentLevel<NB_LEVELS)
|
|
loadLevel(currentLevel+1);
|
|
}
|
|
|
|
if (key==KEY_9)
|
|
{
|
|
BlackFrag=true;
|
|
WhiteFrag=true;
|
|
RedFrag=true;
|
|
GreenFrag=true;
|
|
BlueFrag=true;
|
|
}
|
|
|
|
if (key==KEY_3)
|
|
{
|
|
BlackFrag=false;
|
|
WhiteFrag=false;
|
|
RedFrag=false;
|
|
GreenFrag=false;
|
|
BlueFrag=false;
|
|
}
|
|
|
|
if (key==KEY_8 && NbBossLevel!=0)
|
|
{
|
|
attackboss = true;
|
|
}
|
|
#endif
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static int get_inputs_end(void)
|
|
{
|
|
int opt = GETKEY_DEFAULT & ~GETKEY_REP_ARROWS;
|
|
int timeout = 1;
|
|
|
|
while(1)
|
|
{
|
|
key_event_t ev = getkey_opt(opt, &timeout);
|
|
if(ev.type == KEYEV_NONE) return -1;
|
|
|
|
int key = ev.key;
|
|
|
|
if (key==KEY_EXE || key==KEY_EXIT)
|
|
{
|
|
doneEnd = true;
|
|
GotoMainMenu = true ;
|
|
}
|
|
|
|
/*
|
|
if (key==KEY_UP && selectEndMenu>1)
|
|
selectEndMenu--;
|
|
|
|
if (key==KEY_DOWN && selectEndMenu<2)
|
|
selectEndMenu++;
|
|
*/
|
|
|
|
}
|
|
}
|
|
|
|
void drawEndMenu( void )
|
|
{
|
|
doneEnd = false;
|
|
|
|
selectEndMenu = 0;
|
|
|
|
unsigned int positionGuy = 75;
|
|
int dir = 1;
|
|
|
|
frame = 0;
|
|
|
|
while (!doneEnd)
|
|
{
|
|
dclear(C_RGB(0,0,0));
|
|
|
|
dimage( 0, 10, &bigparch);
|
|
|
|
//dfont( &font_fantasy );
|
|
//dprint( 70, 45, C_RGB(150,150,150), "The END ... ");
|
|
//dprint( 69, 44, C_BLACK, "The END ...");
|
|
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 60, 57, C_RGB(150,150,150), "Congratulation my Dear Friend !!!");
|
|
dprint( 59, 56, C_BLACK, "Congratulation my Dear Friend !!!");
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 55, 69, C_RGB(150,150,150), " " );
|
|
dprint( 54, 68, C_BLACK, " " );
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 60, 81, C_RGB(150,150,150), "You defeated the Sorcerer and you brought" );
|
|
dprint( 59, 80, C_BLACK, "You defeated the Sorcerer and you brought" );
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 60, 93, C_RGB(150,150,150), "back the Jewel of Colors to the village. " );
|
|
dprint( 59, 92, C_BLACK, "back the Jewel of Colors to the village. " );
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 60, 105, C_RGB(150,150,150), "You are now a Hero !!!" );
|
|
dprint( 59, 104, C_BLACK, "You are now a Hero !!!" );
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 65, 117, C_RGB(150,150,150), " " );
|
|
dprint( 64, 116, C_BLACK, " " );
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 65, 129, C_RGB(150,150,150), " " );
|
|
dprint( 64, 128, C_BLACK, "" );
|
|
|
|
dfont( &font_fantasy );
|
|
dprint( 65, 141, C_RGB(150,150,150), "The End ... At least for Now !!" );
|
|
dprint( 64, 140, C_BLACK, "The End ... At least for Now !!" );
|
|
|
|
if (dir==1) // the guy is going to the right
|
|
{
|
|
|
|
if (positionGuy>=285) dir=-1;
|
|
|
|
if (frame==0) dsubimage( positionGuy, 117, &player, 0,16,16,16, DIMAGE_NONE);
|
|
else if (frame==1) dsubimage( positionGuy, 117, &player, 16,16,16,16, DIMAGE_NONE);
|
|
else if (frame==2) dsubimage( positionGuy, 117, &player, 32,16,16,16, DIMAGE_NONE);
|
|
|
|
frame++;
|
|
positionGuy+=1;
|
|
if (frame==3) frame=0;
|
|
}
|
|
else if (dir==-1) // the guy is going to the left
|
|
{
|
|
if (positionGuy<=75) dir=1;
|
|
|
|
if (frame==0) dsubimage( positionGuy, 117, &player, 0,48,16,16, DIMAGE_NONE);
|
|
else if (frame==1) dsubimage( positionGuy, 117, &player, 16,48,16,16, DIMAGE_NONE);
|
|
else if (frame==2) dsubimage( positionGuy, 117, &player, 32,48,16,16, DIMAGE_NONE);
|
|
|
|
frame++;
|
|
positionGuy-=1;
|
|
if (frame==3) frame=0;
|
|
}
|
|
|
|
|
|
dfont( &font_tiny );
|
|
dprint( 60, 170, C_RGB(150,150,150), "[EXE/EXIT] >>>");
|
|
dprint( 59, 169, C_BLACK,"[EXE/EXIT] >>>");
|
|
|
|
dupdate();
|
|
|
|
get_inputs_end();
|
|
}
|
|
|
|
|
|
doneEnd = false;
|
|
int framevillage = 0;
|
|
|
|
int nbstep = 128;
|
|
|
|
memcpy( palette, village.data, 512 );
|
|
uint16_t paletteNB[256];
|
|
uint16_t paletteTemp[256];
|
|
|
|
uint16_t paletteStart[256][3];
|
|
uint16_t paletteEnd[256][3];
|
|
uint16_t paletteNow[256][3];
|
|
int16_t paletteDelta[256][3];
|
|
|
|
for( int k=0; k<255; k++)
|
|
{
|
|
unsigned char B=(unsigned char) ((palette[k] & 0b0000000000011111)<<3);
|
|
unsigned char G=(unsigned char) (((palette[k] & 0b0000011111100000) >> 5)<<2);
|
|
unsigned char R=(unsigned char) (((palette[k] & 0b1111100000000000) >> 11)<<3);
|
|
|
|
paletteEnd[k][0] = R<<8;
|
|
paletteEnd[k][1] = G<<8;
|
|
paletteEnd[k][2] = B<<8;
|
|
|
|
uint16_t Moy = (0.299*R+0.587*G+0.114*B);
|
|
|
|
paletteStart[k][0] = Moy<<8;
|
|
paletteStart[k][1] = Moy<<8;
|
|
paletteStart[k][2] = Moy<<8;
|
|
|
|
paletteDelta[k][0] = (paletteEnd[k][0] - paletteStart[k][0])/nbstep;
|
|
paletteDelta[k][1] = (paletteEnd[k][1] - paletteStart[k][1])/nbstep;
|
|
paletteDelta[k][2] = (paletteEnd[k][2] - paletteStart[k][2])/nbstep;
|
|
|
|
paletteNB[k]= (uint16_t) (((Moy>>3) << 11) | ((Moy>>2) << 5 ) | (Moy>>3));
|
|
}
|
|
memcpy( village.data, paletteNB, 512 );
|
|
|
|
|
|
doneEnd = false;
|
|
|
|
while (!doneEnd)
|
|
{
|
|
dclear(C_RGB(0,0,0));
|
|
|
|
dimage( 0, 10, &bigparch);
|
|
|
|
if (framevillage<=nbstep)
|
|
{
|
|
for( int k=0; k<255; k++)
|
|
{
|
|
paletteNow[k][0] = (paletteStart[k][0]+framevillage*paletteDelta[k][0])>>8;
|
|
paletteNow[k][1] = (paletteStart[k][1]+framevillage*paletteDelta[k][1])>>8;
|
|
paletteNow[k][2] = (paletteStart[k][2]+framevillage*paletteDelta[k][2])>>8;
|
|
paletteTemp[k] = (uint16_t) (((paletteNow[k][0]>>3) << 11) | ((paletteNow[k][1]>>2) << 5 ) | (paletteNow[k][2]>>3));
|
|
}
|
|
memcpy( village.data, paletteTemp, 512 );
|
|
}
|
|
else
|
|
{
|
|
memcpy( village.data, paletteNB, 512 );
|
|
}
|
|
|
|
framevillage++;
|
|
if (framevillage>=nbstep) framevillage=nbstep;
|
|
|
|
dimage( 63, 41, &village);
|
|
|
|
|
|
dfont( &font_tiny );
|
|
dprint( 60, 170, C_RGB(150,150,150), "[EXE/EXIT] >>>");
|
|
dprint( 59, 169, C_BLACK,"[EXE/EXIT] >>>");
|
|
|
|
dupdate();
|
|
|
|
get_inputs_end();
|
|
}
|
|
|
|
|
|
doneEnd = false;
|
|
|
|
while (!doneEnd)
|
|
{
|
|
dclear(C_RGB(0,0,0));
|
|
|
|
dimage( 0, 10, &bigparch);
|
|
dimage( 88, 42, &maintitle);
|
|
dimage( 108, 105, &theend);
|
|
|
|
dfont( &font_tiny );
|
|
dprint( 118, 170, C_RGB(150,150,150), "[EXE/EXIT] Back to Main Menu");
|
|
dprint( 117, 169, C_BLACK,"[EXE/EXIT] Back to Main Menu");
|
|
|
|
dupdate();
|
|
|
|
get_inputs_end();
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void the_end( void )
|
|
{
|
|
drawEndMenu( );
|
|
}
|
|
|
|
|
|
int main ( int argc, char** argv )
|
|
{
|
|
|
|
do
|
|
{
|
|
|
|
selectStartMenu = 0;
|
|
selectDifficultyMenu = 0;
|
|
selectOptionMenu = 0;
|
|
selectOptionPause = 0;
|
|
selectOptionLoose = 0;
|
|
selectStoryMenu = 0;
|
|
selectEndMenu = 0;
|
|
difficulty = 0;
|
|
|
|
doneGame = false;
|
|
doneMain = false;
|
|
doneOption = false;
|
|
donePause = false;
|
|
doneStart = false;
|
|
doneTitle = false;
|
|
doneStory = false;
|
|
doneEnd = false;
|
|
GotoMainMenu=false;
|
|
|
|
drawTitle();
|
|
|
|
unsigned char choice = drawStartMenu();
|
|
|
|
if (choice==0)
|
|
{
|
|
initMap();
|
|
loadprogress();
|
|
|
|
synchroniseGame( );
|
|
loadLevel( currentLevel );
|
|
adjustLevel( currentLevel );
|
|
|
|
}
|
|
else if (choice==1)
|
|
{
|
|
// We start a new game, so we load Level #000
|
|
difficulty= drawDifficultyMenu();
|
|
|
|
BlackFrag = false;
|
|
WhiteFrag = false;
|
|
RedFrag = false;
|
|
GreenFrag = false;
|
|
BlueFrag = false;
|
|
score = 0;
|
|
|
|
if (difficulty==0) life=5;
|
|
else if (difficulty==1) life=3;
|
|
else if (difficulty==2) life=1;
|
|
|
|
drawStoryMenu();
|
|
|
|
initMap();
|
|
|
|
loadLevel( 0 );
|
|
}
|
|
else if (choice==2)
|
|
{
|
|
exitAndFree();
|
|
return 0;
|
|
}
|
|
|
|
initWalls();
|
|
|
|
while (!doneGame)
|
|
{
|
|
dclear(C_RGB(0,0,0));
|
|
|
|
frame_cursor++;
|
|
frame_cursor = frame_cursor % 4;
|
|
|
|
drawInterface( );
|
|
drawMinimap( );
|
|
renderMap( );
|
|
|
|
checkDoors( );
|
|
renderDoors( );
|
|
|
|
renderObstacles( LAYER_BELOW_RAYS );
|
|
renderObstacles( LAYER_ABOVE_RAYS );
|
|
|
|
renderWalls( );
|
|
|
|
checkReceptors( );
|
|
renderReceptors( );
|
|
|
|
renderMovable( );
|
|
|
|
renderLight( );
|
|
renderTreasures( );
|
|
|
|
renderMonsters( );
|
|
renderBoss( );
|
|
|
|
if (attackboss==false && NbBossLevel!=0 && frame_boss_attack == 0 )
|
|
{
|
|
srand( rtc_ticks() );
|
|
unsigned char randomattack = rand() % 101;
|
|
|
|
if (randomattack>=45 && randomattack<=65) launch_Boss_Attack();
|
|
}
|
|
if (attackboss==true) launch_Boss_Attack();
|
|
|
|
|
|
renderPlayer( );
|
|
|
|
dupdate();
|
|
|
|
get_inputs();
|
|
|
|
|
|
updateCurrentState( );
|
|
|
|
|
|
if (life==0) drawLoose();
|
|
|
|
if (selectOptionPause==1 || selectOptionPause==2 || selectOptionLoose==1) doneGame=true;
|
|
if (life==0 && selectOptionLoose==0)
|
|
{
|
|
if (difficulty==0) life=5;
|
|
else if (difficulty==1) life=3;
|
|
else if (difficulty==2) life=1;
|
|
|
|
loadLevel( currentLevel);
|
|
}
|
|
|
|
if (WhiteFrag && BlackFrag && RedFrag && GreenFrag && BlueFrag )
|
|
{
|
|
the_end();
|
|
doneGame=true;
|
|
gint_world_switch( GINT_CALL( delete_save ) );
|
|
initMap();
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
//updateCurrentState( );
|
|
|
|
if (doneEnd==false) gint_world_switch( GINT_CALL( saveprogress ) );
|
|
|
|
}
|
|
while (GotoMainMenu);
|
|
|
|
exitAndFree( );
|
|
|
|
return 0;
|
|
}
|