Пример #1
0
// Relativement inutile, initialise un joueur en position 0 avec une main vide
void initialiserJoueur(Joueur *player){
	player->main = creerMain();
	player->taille = TAILLECOMBINAISON;
	initTableau(player->mainAnalysee, player->taille);
	player->argent = ARGENT; 
	player->position = 0;
}
Пример #2
0
//Tri la structure selon un tri par insertion puis élimine les occurrences nulles de symbole
void TriArbreTableau(ArbreSymbole* a, TabHuff* t) {
	int i, j, x, y;

	initTableau(t);
	ecritTableau(a, t, 128, 0, 0);

	for (j = 1; j<t->Taille; j++) {
		x = t->Symbole[j];
		y = t->Occurrence[j];
		i = j - 1;

		while (i >= 0 && t->Occurrence[i] > y) {
			t->Symbole[i + 1] = t->Symbole[i];
			t->Occurrence[i + 1] = t->Occurrence[i];
			i--;
		}
		t->Symbole[i + 1] = x;
		t->Occurrence[i + 1] = y;
	}
	i = 0;

	while (t->Taille != 0 && t->Occurrence[0] == 0) {
		for (j = 0; j<t->Taille; j++) {
			t->Symbole[j] = t->Symbole[j + 1];
			t->Occurrence[j] = t->Occurrence[j + 1];
		}
		t->Taille--;
	}
}
Пример #3
0
// DECONSEILLE Relativement inutile, crée un joueur et l'initialise en position pos passée en paramètre avec une main vide puis le renvoie
Joueur creerJoueur(int pos){
	Joueur player;
	player.main = creerMain();
	player.taille = TAILLECOMBINAISON;
	initTableau(player.mainAnalysee, player.taille);
	player.argent = ARGENT; 
	player.position = pos;
	return player;
}
Пример #4
0
int main(int argc, char* argv[])
{
    /* INITIALISATIONS DES BIBLIOTHEQUES : IMG, SDL, TTF */
    IMG_Init(IMG_INIT_PNG);
    SDL_Init(SDL_INIT_VIDEO);
    TTF_Init();

    Message msgs[NOMBRE_MESSAGES];
    initMessage(msgs);

    SDL_Surface *ecran = SDL_SetVideoMode(LARGEUR, HAUTEUR, BPP, SDL_HWSURFACE | SDL_DOUBLEBUF);

    /* Titre */
    SDL_WM_SetCaption("Duck Hunt", NULL);

    /* Icone */
    SDL_WM_SetIcon(SDL_LoadBMP("sprites/icon.bmp"), NULL);

    /* Initialisation des variables en rapport avec le temps */
    Time temps;
    initTime(temps);
    srand((unsigned)time(NULL));

    int modeJeu = 0;    // Le mode de jeu.
    int modeMenu = 1;   // Détermine la page du menu à afficher.

    Partie partie;
    partie.score = 0;
    partie.niveau = 0;
    Sprites sprites;
    Chien chien;

    Boutons boutons;
    initBouton(boutons);

    chargerImages(sprites, chien, boutons, "classique");
    boutons.bouton[BOUTON_THEME_CLASSIQUE].actif = true;

    Uint8 *keystate = SDL_GetKeyState(NULL);
    SourisEvent sourisEvent;
    initSourisEvent(sourisEvent);

    initFichiers();

    SDL_ShowCursor(SDL_DISABLE);

    menu(ecran, sprites, boutons, modeMenu, modeJeu, sourisEvent, temps, msgs, partie, chien);
    while (modeJeu != 0)
    {
        if (modeMenu != 0)
        {
            menu(ecran, sprites, boutons, modeMenu, modeJeu, sourisEvent, temps, msgs, partie, chien);
        }
        temps.currentTime = SDL_GetTicks();
        partie.alreadyShot = partie.alreadyGetEvent = partie.alreadyClic = false;
        for (int i = 0 ; i < sprites.canardActifs ; i++)
        {
            shoot(sourisEvent, sprites.canard[i], partie, temps, modeJeu);
            if ((temps.currentTime >= sprites.canard[i].vitesseTime + sprites.canard[i].vitesse))
            {
                mouvementsCanard(sprites.canard[i]);
                detectionBordsCanard(sprites.canard[i], partie, i);
                changementDirection(sprites.canard[i]);
                if(sprites.canard[i].etat == TOUCHED)
                {
                    touched(sprites.canard[i], temps);
                }
                sprites.canard[i].vitesseTime = temps.currentTime;
            }
            if (temps.currentTime >= sprites.canard[i].vitesseAnimationTime + sprites.canard[i].vitesseAnimation)
            {
                switchSpriteCanard(sprites.canard[i]);
                sprites.canard[i].vitesseAnimationTime = temps.currentTime;
            }
        }
        if(partie.shots <= 0)
        {
            for(int i = 0 ; i < sprites.canardActifs ; i++)
            {
                canardSurvivant(sprites, partie, i);
            }
        }
        if (temps.currentTime >= chien.vitesseAnimationTime + chien.vitesseAnimation)
        {
            switchSpriteChien(chien, partie);
            controlesChien(chien, partie, sprites);
            ramasserCanard(chien, partie, sprites);

            chien.vitesseAnimationTime = temps.currentTime;
            ramasserCanard(chien, partie, sprites);
        }
        if(partie.relancer)
        {
            relancerPartie(partie, sprites);
        }
        if(partie.round >= 5)
        {
            if(finPartie(partie))
            {
                if (testHighScore("scoresClassic", partie))
                {
                    modeMenu = 8;
                }
                else
                {
                    modeMenu = 9;
                }
            }
            else
            {
                partie.round = 0;
                partie.niveau ++;
                initPartie(partie, sprites.canardActifs);
                partie.jeu = true;
                for (int i=0; i<sprites.canardActifs; i++)
                {
                    initCanard(sprites.canard[i], partie);
                }
                initTableau(partie.tableauChasse, sprites);
                modeMenu = 6;
            }
        }
        if (keystate[SDLK_ESCAPE])
        {
            modeMenu = 5;
        }
        if (temps.currentTime >= temps.timeFps + temps.fpsTime)
        {
            genererRendu(ecran, sprites, sourisEvent, partie, chien, msgs);
            SDL_Flip(ecran);
            temps.timeFps = temps.currentTime;
        }

        SDL_Delay(1);
    }
    libererImages(sprites, chien, boutons);
    SDL_Quit();
    IMG_Quit();
    TTF_Quit();
    return EXIT_SUCCESS;
}
Пример #5
0
void menu(SDL_Surface *ecran, Sprites &sprites, Boutons &boutons, int &modeMenu, int &modeJeu, SourisEvent &sourisEvent, Time &time, Message msgs[], Partie &partie, Chien &chien)
{
    bool sortir = false;
    int lastKeyPressed;
    int lastKeyPressedBis;
    int lastMenu = 1;
    bool keyPressed = false;
    bool keyPressedBis = false;
    bool defilTouche = false;
    for (int i=0; i<LONGUEUR_MAX_PSEUDO; i++)
    {
        partie.pseudoT[i] = 0;
    }
    getScore("scoresClassic", partie.highScore);
    int carActif = 0;
    Uint8 *keystate = SDL_GetKeyState(NULL);
    time.currentTime = SDL_GetTicks();
    time.timeMenu = time.currentTime;
    time.timeKey = time.currentTime;
    time.timeDefKey = time.currentTime;
    while (!sortir && modeMenu!=0)
    {
        if (getEvents(sourisEvent, 1))
        {
            modeMenu = 0;
            modeJeu = 0;
        }
        time.currentTime = SDL_GetTicks();
        switch (modeMenu)
        {
        case 0:
            sortir = true;
            break;
        case 1 :
            boutons.bouton[BOUTON_PLAY].position.x = (LARGEUR - boutons.lecture[0].w) / 2;
            boutons.bouton[BOUTON_PLAY].position.y = 100;

            boutons.bouton[BOUTON_SCORE].position.x = (LARGEUR - boutons.lecture[0].w) / 2;
            boutons.bouton[BOUTON_SCORE].position.y = 250;

            boutons.bouton[BOUTON_OPTIONS].position.x = (LARGEUR - boutons.lecture[0].w) / 2;
            boutons.bouton[BOUTON_OPTIONS].position.y = 400;

            boutons.bouton[BOUTON_QUIT].position.x = (LARGEUR - boutons.lecture[0].w) / 2;
            boutons.bouton[BOUTON_QUIT].position.y = 550;

            if ((testHoverBouton(sourisEvent.sx, sourisEvent.sy, boutons.bouton[BOUTON_QUIT], boutons.lecture[0]))&&sourisEvent.clicGauche)
            {
                modeMenu = 0;
                modeJeu = 0;
            }
            else if ((testHoverBouton(sourisEvent.sx, sourisEvent.sy, boutons.bouton[BOUTON_PLAY], boutons.lecture[0]))&&sourisEvent.clicGauche)
            {
                time.currentTime = SDL_GetTicks();
                time.timeMenu = time.currentTime;
                modeJeu = 1;
                modeMenu = 6;
                initChien(chien);

                sprites.canardActifs = 2;

                for (int i = 0 ; i < sprites.canardActifs ; i++)
                {
                    sprites.canard[i].type = alea(0, 3);
                    initCanard(sprites.canard[i], partie);
                }
                partie.niveau = 0;
                partie.score = 0;
                initPartie(partie, sprites.canardActifs);
                initTableau(partie.tableauChasse, sprites);
            }
            else if ((testHoverBouton(sourisEvent.sx, sourisEvent.sy, boutons.bouton[BOUTON_SCORE], boutons.lecture[0]))&&sourisEvent.clicGauche)
            {
                modeMenu = 7;
            }
            else if ((testHoverBouton(sourisEvent.sx, sourisEvent.sy, boutons.bouton[BOUTON_OPTIONS], boutons.lecture[0]))&&sourisEvent.clicGauche)
            {
                modeMenu = 2;
            }
            break;
        case 2:
            boutons.bouton[BOUTON_RETOUR].position.x = (LARGEUR/2) - (boutons.lecture[0].w/2);
            boutons.bouton[BOUTON_RETOUR].position.y = 600;

            boutons.bouton[BOUTON_THEME_CLASSIQUE].position.x = ((LARGEUR/2) - (boutons.lecture[0].w/2))/2;
            boutons.bouton[BOUTON_THEME_CLASSIQUE].position.y = 200;

            boutons.bouton[BOUTON_THEME_ISLAND].position.x = (((LARGEUR/2) - (boutons.lecture[0].w/2))/2)+((LARGEUR/2) - (boutons.lecture[0].w/2));
            boutons.bouton[BOUTON_THEME_ISLAND].position.y = 200;

            if ((testHoverBouton(sourisEvent.sx, sourisEvent.sy, boutons.bouton[BOUTON_RETOUR], boutons.lecture[0]))&&sourisEvent.clicGauche)
            {
                modeMenu = lastMenu;
            } else if ((testHoverBouton(sourisEvent.sx, sourisEvent.sy, boutons.bouton[BOUTON_THEME_CLASSIQUE], boutons.lecture[0]))&&sourisEvent.clicGauche)
            {
                boutons.bouton[BOUTON_THEME_CLASSIQUE].actif = true;
                boutons.bouton[BOUTON_THEME_ISLAND].actif = false;
                libererImages(sprites, chien, boutons);
                chargerImages(sprites, chien, boutons, "classique");
            } else if ((testHoverBouton(sourisEvent.sx, sourisEvent.sy, boutons.bouton[BOUTON_THEME_ISLAND], boutons.lecture[0]))&&sourisEvent.clicGauche)
            {
                boutons.bouton[BOUTON_THEME_CLASSIQUE].actif = false;
                boutons.bouton[BOUTON_THEME_ISLAND].actif = true;
                libererImages(sprites, chien, boutons);
                chargerImages(sprites, chien, boutons, "island");
            }
            break;
        case 5 :
            boutons.bouton[BOUTON_REPRENDRE].position.x = (LARGEUR/2) - (boutons.lecture[0].w/2);
            boutons.bouton[BOUTON_REPRENDRE].position.y = 200;

            boutons.bouton[BOUTON_OPTIONS].position.x = (LARGEUR/2) - (boutons.lecture[0].w/2);
            boutons.bouton[BOUTON_OPTIONS].position.y = 400;

            boutons.bouton[BOUTON_QUIT].position.x = (LARGEUR/2) - (boutons.lecture[0].w/2);
            boutons.bouton[BOUTON_QUIT].position.y = 600;

            if ((testHoverBouton(sourisEvent.sx, sourisEvent.sy, boutons.bouton[BOUTON_QUIT], boutons.lecture[0]))&&sourisEvent.clicGauche)
            {
                modeMenu = 1;
                lastMenu = 1;
            }
            else if ((testHoverBouton(sourisEvent.sx, sourisEvent.sy, boutons.bouton[BOUTON_REPRENDRE], boutons.lecture[0]))&&sourisEvent.clicGauche)
            {
                modeMenu = 0;
            } else if ((testHoverBouton(sourisEvent.sx, sourisEvent.sy, boutons.bouton[BOUTON_OPTIONS], boutons.lecture[0]))&&sourisEvent.clicGauche)
            {
                modeMenu = 2;
                lastMenu = 5;
            }
            break;
        case 6:
            if (time.currentTime >= time.menuTime + time.timeMenu)
            {
                modeMenu = 0;
                time.timeMenu = time.currentTime;
            }
            break;
        case 7:
            boutons.bouton[BOUTON_RETOUR].position.x = (LARGEUR/2) - (boutons.lecture[0].w/2);
            boutons.bouton[BOUTON_RETOUR].position.y = 600;

            if ((testHoverBouton(sourisEvent.sx, sourisEvent.sy, boutons.bouton[BOUTON_RETOUR], boutons.lecture[0]))&&sourisEvent.clicGauche)
            {
                modeMenu = 1;
            }
            break;
        case 8:
            boutons.bouton[BOUTON_OK].position.x = (LARGEUR/2) - (boutons.lecture[0].w/2);
            boutons.bouton[BOUTON_OK].position.y = 600;

            lastKeyPressedBis = lastKeyPressed;
            keyPressedBis = keyPressed;
            keyPressed = false;
            if (carActif < LONGUEUR_MAX_PSEUDO-1)
            {
                for (int i=97; i<123; i++)
                {
                    if (keystate[i])
                    {
                        lastKeyPressed = i;
                        keyPressed = true;
                    }
                }
            }
            if ((carActif > 0)&&keystate[SDLK_BACKSPACE])
            {
                lastKeyPressed = -1;
                keyPressed = true;
            }
            if ((lastKeyPressedBis !=lastKeyPressed)||(defilTouche&&(time.currentTime >= time.timeDefKey + time.defKeyTime))||(keyPressedBis!=keyPressed))
            {
                if (keyPressedBis!=keyPressed)
                {
                    defilTouche = false;
                }
                if (carActif < LONGUEUR_MAX_PSEUDO-1)
                {
                    for (int i=97; i<123; i++)
                    {
                        if (keystate[i])
                        {
                            partie.pseudoT[carActif]=(i-32);
                            carActif++;
                            time.timeKey = time.currentTime;
                        }
                    }
                }
                if ((carActif > 0)&&keystate[SDLK_BACKSPACE])
                {
                    partie.pseudoT[carActif-1]=0;
                    carActif--;
                    time.timeKey = time.currentTime;
                }
                if (defilTouche)
                {
                    time.timeDefKey = time.currentTime;
                }
            }
            else
            {
                if ((time.currentTime >= time.timeKey + time.keyTime)&&keyPressed)
                {
                    defilTouche = true;
                }
            }

            partie.pseudo = std::string(partie.pseudoT);
            if ((testHoverBouton(sourisEvent.sx, sourisEvent.sy, boutons.bouton[BOUTON_OK], boutons.lecture[0]))&&sourisEvent.clicGauche)
            {
                addScore("scoresClassic", partie.pseudo, partie.score, partie.highScore);
                modeMenu = 7;
            }
            break;
        case 9:
            boutons.bouton[BOUTON_RETOUR].position.x = (LARGEUR/2) - (boutons.lecture[0].w/2);
            boutons.bouton[BOUTON_RETOUR].position.y = 600;

            if ((testHoverBouton(sourisEvent.sx, sourisEvent.sy, boutons.bouton[BOUTON_RETOUR], boutons.lecture[0]))&&sourisEvent.clicGauche)
            {
                modeMenu = 1;
            }
            break;
        default:
            break;
        }
        if (time.currentTime >= time.timeFps + time.fpsTime)
        {
            showMenu(ecran, sprites, boutons, modeMenu, msgs, partie, sourisEvent.sx, sourisEvent.sy);
            time.timeFps = time.currentTime;
        }
        SDL_Flip(ecran);
    }
}