Ejemplo n.º 1
0
/**
 * administrationCours(T_Section *, choix): Cette fonction permet d'ajouter/modifier/supprimer/afficher
 * les cours donnés en l'année dont on reçoit le pointeur en paramètre. Elle permet
 * aussi d'en modifier les pondérations.
 * @param: pointeur vers la section qui contient l'année à administrer.
 * @param: l'index dans le tableau section correspondant à l'année choisie.
 */
void administrerCours(T_Section *section, int anneeChoisie){
	int choix, i;
	do{
		effacerEcran();
		printf("***Gestion des cours de %s***\n\n", section->tabAnnees[anneeChoisie].nomAnneeSection);

		printf("\t1. Afficher les cours et leurs ponderations\n");
		printf("\t2. Ajouter un cours\n");
		printf("\t3. Modifier un cours\n");
		printf("\t4. Supprimer un cours\n");
		printf("\t5. Enregistrer le fichier des cours\n");
		printf("\t6. Retour\n");
		printf("\nVotre choix: ");
		choix = getNumber(1, 6);

		switch(choix){
		case 1:
			effacerEcran();
			afficherCours(section->tabAnnees[anneeChoisie]);
			system("PAUSE");
			break;
		case 2:
			ajouterCours(&section->tabAnnees[anneeChoisie]);

			break;
		case 3:
			modifierCours(&section->tabAnnees[anneeChoisie]);
			break;
		case 4:
			supprimerCours(&section->tabAnnees[anneeChoisie]);
			break;
		case 5:
			sauverFichierParametrage(*section); //On enregistre les cours
			//Mais aussi les étudiants car si l'on a supprimé un cours, ce cours a également été supprimé
			//chez tous les étudiants, il faut par conséquent les enregistrer tous.
			for(i = 0; i < section->tabAnnees[anneeChoisie].nbClasses; i++)
				sauvegarderClasse(section->tabAnnees[anneeChoisie].tabClasse[i], section->nom, section->tabAnnees[anneeChoisie].nomAnneeSection);
			printf("\nEnregistrement effectue !\n");
			system("PAUSE");
			break;
		}
	}while(choix != 6);
}
Ejemplo n.º 2
0
void afficherMenuChoixClasse(T_Section sct, int choix)
{
    int i, choixAnnee;
    do{
		effacerEcran();

		printf("Sur quelle classe de la section %s voulez vous travailler ?\n\n", sct.nom);
		for(i = 0 ; i < sct.tabAnnees[choix].nbClasses ; i++)
			printf("\t%d. %s\n", i+1, sct.tabAnnees[choix].nomClasse[i]);

		printf("\t%d. Ou administrer les cours donnes en cette annee", i+1);
		printf("\n\n\t%d. Retour", i+2);

		printf("\n\nVotre choix : ");
		choixAnnee = getNumber(1, i+2);

		if(choixAnnee == (i+1))
			administrerCours(&sct, choix);
		else if(choixAnnee != i+2)
			administrationClasse(&sct, choix, choixAnnee-1);
    }while(choixAnnee != i+2);
   }
Ejemplo n.º 3
0
Uint8 interpreterOpcode(Uint16 opcode) 
{ 
  Uint8 continuer=1; 
  Uint8 b4,b3,b2,b1; 

  b3=(opcode&(0x0F00))>>8;  //on prend les 4 bits représentant X 
  b2=(opcode&(0x00F0))>>4;  //idem pour Y 
  b1=(opcode&(0x000F));     //idem 

  b4= recupererAction(opcode); 

  switch(b4) 
  { 
    case 0:{ 
             //Cet opcode n'est pas implémenté. 
             break; 
           } 
    case 1:{ 
             //00E0 efface l'écran. 
             effacerEcran(); 
             break; 
           } 

    case 2:{ 
             //00EE revient du saut. 

             if(cpu.nbrsaut>0) 
             { 
               cpu.nbrsaut--; 
               cpu.pc=cpu.saut[cpu.nbrsaut]; 
             } 
             break; 
           } 
    case 3:{ 
             //1NNN effectue un saut à l'adresse 1NNN. 

             cpu.pc=(b3<<8)+(b2<<4)+b1; //on prend le nombre NNN (pour le saut) 
             cpu.pc-=2; //on verra pourquoi à la fin 

             break; 
           } 
    case 4:{ 
             //2NNN appelle le sous-programme en NNN, mais on revient ensuite. 

             cpu.saut[cpu.nbrsaut]=cpu.pc; //on reste là où on était 

             if(cpu.nbrsaut<15) 
             { 
               cpu.nbrsaut++; 
             } 

             cpu.pc=(b3<<8)+(b2<<4)+b1; //on prend le nombre NNN (pour le saut) 
             cpu.pc-=2; //on verra pourquoi à la fin 

             break; 
           } 
    case 5:{ 
             //3XNN saute l'instruction suivante si VX est égal à NN. 

             if(cpu.V[b3]==((b2<<4)+b1)) 
             { 
               cpu.pc+=2; 
             } 

             break; 
           } 
    case 6:{ 
             //4XNN saute l'instruction suivante si VX et NN ne sont pas égaux. 
             if(cpu.V[b3]!=((b2<<4)+b1)) 
             { 
               cpu.pc+=2; 
             } 

             break; 
           } 
    case 7:{ 
             //5XY0 saute l'instruction suivante si VX et VY sont égaux. 
             if(cpu.V[b3]==cpu.V[b2]) 
             { 
               cpu.pc+=2; 
             } 

             break; 
           } 

    case 8:{ 
             //6XNN définit VX à NN. 
             cpu.V[b3]=(b2<<4)+b1; 
             break; 
           } 
    case 9:{ 
             //7XNN ajoute NN à VX. 
             cpu.V[b3]+=(b2<<4)+b1; 

             break; 
           } 
    case 10:{ 
              //8XY0 définit VX à la valeur de VY. 
              cpu.V[b3]=cpu.V[b2]; 

              break; 
            } 
    case 11:{ 
              //8XY1 définit VX à VX OR VY. 
              cpu.V[b3]=cpu.V[b3]|cpu.V[b2]; 

              break; 
            } 
    case 12:{ 
              //8XY2 définit VX à VX AND VY. 
              cpu.V[b3]=cpu.V[b3]&cpu.V[b2]; 

              break; 
            } 
    case 13:{ 
              //8XY3 définit VX à VX XOR VY. 
              cpu.V[b3]=cpu.V[b3]^cpu.V[b2]; 

              break; 
            } 
    case 14:{ 
              //8XY4 ajoute VY à VX. VF est mis à 1 quand il y a un dépassement de mémoire (carry), et à 0 quand il n'y en pas. 
              if((cpu.V[b3]+cpu.V[b2])>255) 
              { 
                cpu.V[0xF]=1; //cpu.V[15] 
              } 
              else 
              { 
                cpu.V[0xF]=0; //cpu.V[15] 
              } 
              cpu.V[b3]+=cpu.V[b2]; 

              break; 
            } 
    case 15:{ 
              //8XY5 VY est soustraite de VX. VF est mis à 0 quand il y a un emprunt, et à 1 quand il n'y a en pas. 

              if((cpu.V[b3]<cpu.V[b2])) 
              { 
                cpu.V[0xF]=0; //cpu.V[15] 
              } 
              else 
              { 
                cpu.V[0xF]=1; //cpu.V[15] 
              } 
              cpu.V[b3]-=cpu.V[b2]; 

              break; 
            } 
    case 16:{ 
              //8XY6 décale (shift) VX à droite de 1 bit. VF est fixé à la valeur du bit de poids faible de VX avant le décalage. 
              cpu.V[0xF]=(cpu.V[b3]&(0x01)); 
              cpu.V[b3]=(cpu.V[b3]>>1); 

              break; 
            } 
    case 17:{ 
              //8XY7 VX = VY - VX. VF est mis à 0 quand il y a un emprunt et à 1 quand il n'y en a pas. 
              if((cpu.V[b2]<cpu.V[b3])) 
              { 
                cpu.V[0xF]=0; //cpu.V[15] 
              } 
              else 
              { 
                cpu.V[0xF]=1; //cpu.V[15] 
              } 
              cpu.V[b3]=cpu.V[b2]-cpu.V[b3]; 

              break; 
            } 
    case 18:{ 
              //8XYE décale (shift) VX à gauche de 1 bit. VF est fixé à la valeur du bit de poids fort de VX avant le décalage. 
              cpu.V[0xF]=(cpu.V[b3]>>7); 
              cpu.V[b3]=(cpu.V[b3]<<1); 

              break; 
            } 

    case 19:{ 
              //9XY0 saute l'instruction suivante si VX et VY ne sont pas égaux. 
              if(cpu.V[b3]!=cpu.V[b2]) 
              { 
                cpu.pc+=2; 
              } 

              break; 
            } 
    case 20:{ 
              //ANNN affecte NNN à I. 

              cpu.I=(b3<<8)+(b2<<4)+b1; 

              break; 
            } 
    case 21:{ 
              //BNNN passe à l'adresse NNN + V0. 

              cpu.pc=(b3<<8)+(b2<<4)+b1+cpu.V[0]; 
              cpu.pc-=2; 

              break; 

            } 
    case 22:{ 
              //CXNN définit VX à un nombre aléatoire inférieur à NN. 
              cpu.V[b3]=(rand())%((b2<<4)+b1+1); 

              break; 

            } 

    case 23:{ 
              //DXYN dessine un sprite aux coordonnées (VX, VY). 


              dessinerEcran(b1,b2,b3) ; 

              break; 

            } 
    case 24:{ 
              //EX9E saute l'instruction suivante si la clé stockée dans VX est pressée. 
              if(cpu.touche[cpu.V[b3]]==1)//1 pressé, 0 relaché 
              { 
                cpu.pc+=2; 
              } 

              break; 
            } 
    case 25:{ 
              //EXA1 saute l'instruction suivante si la clé stockée dans VX n'est pas pressée. 
              if(cpu.touche[cpu.V[b3]]==0)//1 pressé, 0 relaché 
              { 
                cpu.pc+=2; 
              } 

              break; 
            } 

    case 26:{ 
              //FX07 définit VX à la valeur de la temporisation. 
              cpu.V[b3]=cpu.compteurJeu; 

              break; 
            } 
    case 27:{ 
              //FX0A attend l'appui sur une touche et stocke ensuite la donnée dans VX. 
              continuer=attendAppui(b3); 

              break; 
            } 


    case 28:{ 
              //FX15 définit la temporisation à VX. 
              cpu.compteurJeu=cpu.V[b3]; 

              break; 
            } 
    case 29:{ 
              //FX18 définit la minuterie sonore à VX. 
              cpu.compteurSon=cpu.V[b3]; 

              break; 
            } 
    case 30:{ 
              //FX1E ajoute VX à I. VF est mis à 1 quand il y a overflow (I+VX>0xFFF), et à 0 si tel n'est pas le cas. 

              if((cpu.I+cpu.V[b3])>0xFFF) 
              { 
                cpu.V[0xF]=1; 
              } 
              else 
              { 
                cpu.V[0xF]=0; 
              } 
              cpu.I+=cpu.V[b3]; 


              break; 
            } 

    case 31:{ 
              //FX29 définit I à l'emplacement du caractère stocké dans VX. Les caractères 0-F (en hexadécimal) sont représentés par une police 4x5. 
              cpu.I=cpu.V[b3]*5; 

              break; 
            } 

    case 32:{ 
              //FX33 stocke dans la mémoire le code décimal représentant VX (dans I, I+1, I+2). 

              cpu.memoire[cpu.I]=(cpu.V[b3]-cpu.V[b3]%100)/100; 
              cpu.memoire[cpu.I+1]=(((cpu.V[b3]-cpu.V[b3]%10)/10)%10); 
              cpu.memoire[cpu.I+2]=cpu.V[b3]-cpu.memoire[cpu.I]*100-10*cpu.memoire[cpu.I+1]; 

              break; 
            } 
    case 33:{ 
              //FX55 stocke V0 à VX en mémoire à partir de l'adresse I. 
              Uint8 i=0; 
              for(i=0;i<=b3;i++) 
              { 
                cpu.memoire[cpu.I+i]=cpu.V[i]; 
              } 

              break; 
            } 
    case 34:{ 
              //FX65 remplit V0 à VX avec les valeurs de la mémoire à partir de l'adresse I. 

              Uint8 i=0; 

              for(i=0;i<=b3;i++) 
              { 
                cpu.V[i]=cpu.memoire[cpu.I+i]; 
              } 

              break; 
            } 

    default: { //si ça arrive, il y un truc qui cloche 

               break; 
             } 

  } 
  cpu.pc+=2; //on passe au prochain opcode 
  return continuer; 
} 
Ejemplo n.º 4
0
/*
 * administrationAnnees(T_Section*): cette fonction permet de choisir si l'on veut créer
 * ou charger une année.
 * @return: Il retourne 1
 */
void administrationAnnees(T_Section * tab)
{
    int choix = 0, nbrAnneeACreer = 0, i = 0;
    char choixSauver = 0;
    do{
		effacerEcran();
		printf("*** Programme de gestion de classes *** \n\n");
		printf("\t 1. Charger le tableau d'annee de cette section (ex : 1TI) .\n");
		printf("\t 2. Creer une annee\n");
		printf("\n\t 3. Retour\n");

		printf("\nVotre choix : ");
		choix = getNumber(1, 3);


		if(choix == 2)
		{
			if(tab->nbrAnnees > 0)
			{
				printf("Il y'a deja %d annee dans la section %s\n", tab->nbrAnnees, tab->nom);
				printf("Combien d'annees souhaitez vous ajouter : ");
				scanf("%d", &nbrAnneeACreer);

			   tab->tabAnnees = realloc(tab->tabAnnees, (tab->nbrAnnees + nbrAnneeACreer) * sizeof(T_Annee));
			   printf("nbrAnneeACreer: %d\n", nbrAnneeACreer);

				for(i = 0 ; i < nbrAnneeACreer ; i++)
					tab->tabAnnees[tab->nbrAnnees + i] = demanderInfo(tab->tabAnnees[tab->nbrAnnees + i], tab->abbreviation);

				printf("Les nouvelles classes ont correctement ete ajoutee !\n");
				//On incrémente le nombre de classes de la section
				tab->nbrAnnees += nbrAnneeACreer;
				sauverFichierParametrage(*tab);
				for(i=0; i<nbrAnneeACreer+tab->nbrAnnees; i++)
					printf("Nom : %s", tab->tabAnnees[i].nomAnneeSection);

			}

			else
			{
				printf("Nombre d'annee souhaitee : ");
				scanf("%d", &nbrAnneeACreer);
				tab->tabAnnees = malloc(nbrAnneeACreer * sizeof(T_Annee));
				if(tab == NULL)
				{
					printf("Erreur memoire");
					exit(0);
				}

				for(i = 0 ; i < nbrAnneeACreer ; i++)
					tab->tabAnnees[i] = demanderInfo(tab->tabAnnees[i], tab->abbreviation);

				printf("Voulez vous sauvegader ce fichier de parametrage ? : ");
				fflush(stdin);
				scanf("%c", &choixSauver);

				if(choixSauver == 'o' || choixSauver == 'O')
				{
					sauverFichierParametrage(*tab);
				}
				else if(choixSauver == 'n' || choixSauver == 'N')
				{
					effacerEcran();
					//administrationAnnees(tab->tabAnnees);
				}


				free(tab->tabAnnees);
			}
		}
		else if(choix == 1)
		{
			//printf("Chargement des classes effectue.\n\n");
			//system("Pause");
			effacerEcran();
			afficherMenuChoixAnnee(tab);
		}
    }while(choix != 3);
}