Erypiano v2.03 cs4 as3

Description

Le site ErySoft a été sujet à une attaque virale. J'ai rétabli ce dernier, mais Google mentionne et bloque toujours son accès, le temps de réexaminer l'intégrité de ce dernier.

Le 28/12/2011

Chose promise, chose due !

Une première remarque incisive : Flash c'est "POOrrave", et pas un peu. C'est juste bon à faire de la publicité, et des jeux.
Quant à savoir si cette nouvelle source est de la POO, ou pas de la POO, et bien je ne sais "pôô", et c'est tant mieux.
J'ai amélioré le code, en utilisant pas mal de possibilités DE BASES pour faire discuter les .as, mais il faut mieux utiliser les vieilles méthodes qui ont faites leurs preuves. Car si vous désirez obtenir une programme qui ne bouffe pas toutes les ressources µP, il faut éviter de manipuler les tas d'objets prédéfinis juste bons pour faire de la Pub ... du clinquant, du "tape-à-l'œil", du "m'as-tu vu", et j'en passe et des meilleurs.

Les sons ne sont pas présents sur ce site, donc il faut vous rendre à l'adresse suivante, et télécharger le .zip de la version 2 :

http://www.erysoft.fr/erypiano/index.html

Pour ceux qui aiment la bidouille balèze, je vous conseille Pascal DOS 7, si vos machines acceptent encore d'être triturées.

VERSION 1
========

NOTE : Je ne cherche pas à réduire la taille du fichier obtenu. La présence des 88 sons est voulue.

C'est un piano virtuel de 88 touches, avec les sons mp3 CBR128 pré-enregistrés. La taille du fichier fla fait plus de 25 Mo, alors il ne m'est pas possible de le placer sur ce site. De même, le fichier swf compilé fait plus de 15 Mo. Mais vous pouvez trouver les sources complètes et le fichier swf à l'adresse suivante :

http://www.erysoft.fr/erypiano/index.html

On m'a dit qu'il fallait utiliser la POO ! Ben vous avez du pot, c'est pratiquement de la pure POO. Mais je pense franchement que les classes compliquent la compréhension ... enfin, c'est mon avis.

Ce piano virtuel peut jouer des séquences enregistrées au format xml. Pour faire ces fichiers, je vous fournirai l'exécutable VB6 quand il sera vraiment au point. Vous avez un exemple (Etude N°1 Opus 25 de Chopin) inclus, que vous pourrez analyser si cela vous intéresse.

Vous pouvez jouer à l'aide de la souris, ou alors faire des accords en vous positionnant sur la position ACCORD/ARPEGE. Une fenêtre d'aide vous donnera l'utilité de chaque bouton.

Il est préférable d'exécuter cette application avec un lecteur flash. Avec un navigateur, çà rame à mort !

Source / Exemple :


package piano
{
	import flash.display.MovieClip;
	//import flash.ui.Keyboard;
	import flash.media.Sound;
	import flash.media.SoundChannel;
	import flash.media.SoundTransform
	import flash.utils.Timer;
	import flash.display.Sprite;
	import flash.events.TimerEvent;
	import flash.events.Event;
		
	public class erypiano extends MovieClip
	{
		public  const ERYPIANO				: String = new String("ERYPIANO V2.03");
		
		public  const NOTE_SOURIS			: int = 31;
		public  const MODE_SEQUENCEUR		        : int = 0;
		public  const MODE_ACCORD			: int = 1;

		private var parametre				: Object = loaderInfo.parameters;
		
		private var xml_chargeur			: chargeur_xml;
		private var chargeur_note			: chargeur_son;
		private var bouton_jouer			: bouton;
		private var bouton_stopper			: bouton;
		public  var bouton_reculer			: bouton;
		public  var bouton_avancer			: bouton;
		private var bouton_menu_haut		        : bouton;
		private var bouton_menu_bas			: bouton;
		private var bouton_menu_valider		        : bouton;
		private var potentiometre_tempo		        : potentiometre;
		private var potentiometre_volume	        : potentiometre;
		public  var lcd					: affichage_lcd;
		public  var aide				: affichage_aide;
		public  var accord				: generateur_accord;
		public  var clavier				: clavier_piano;
		public  var marquage				: affichage_point;
		public  var sequenceur				: sequenceur_note;
		public  var polyphonie				: affichage_led;
		
		private var cache				: cache_clavier = new cache_clavier();
		private var fenetre				: fenetre_aide = new fenetre_aide();
		
		private var midi				: String = parametre.midi;
		private var midi_xml				: String = parametre.xidi;
		private var sequence				: String = parametre.melo;
		private var configuration			: String = parametre.conf;
		
		public  var mode_piano				: int;
		public  var volume_piano			: int = 80;
		public  var valeur_tempo			: int = 50;
		
		private var initialisation			: Boolean = false;
		
		// Initialisation des objets primaires
		public function erypiano():void
		{
			lcd = new affichage_lcd(this, lcd_texte, "F00", "F01", "F02");
			lcd.addEventListener("F00", charger_note_instrument);
			lcd.addEventListener("F01", charger_sequence_xidi);
			lcd.addEventListener("F02", controle_bouton_stop);
			polyphonie = new affichage_led(this, true, 720, 18);
			marquage = new affichage_point(this, true, 20, 49, cache);
			accord = new generateur_accord(this);
			sequenceur = new sequenceur_note(this);
			chargeur_note = new chargeur_son("F10", "F11");
			chargeur_note.addEventListener("F10", reception_gamme);
			chargeur_note.addEventListener("F11", echo_chargement_son);
			xml_chargeur = new chargeur_xml("F20", "F21", "F22", "F23");
			xml_chargeur.addEventListener("F20", reception_midi_xml);
			xml_chargeur.addEventListener("F21", reception_configuration);
			xml_chargeur.addEventListener("F22", reception_sequence);
			xml_chargeur.addEventListener("F23", echo_chargement_xml);
			if (configuration == null) configuration = "./configuration.xml";
			xml_chargeur.chargement_midi_xml(configuration, "configuration");
		}
		// Initialisation des objets secondaires
		private function initialisation_objet():void
		{
			if (initialisation) return;
			clavier = new clavier_piano(cache, "F30", "F31");
			clavier.addEventListener("F30", touche_enfoncee);
			clavier.addEventListener("F31", touche_relachee);
			aide = new affichage_aide(this, fenetre, 377.5, 100);
			aide.etat_actif = true;
			initialisation_potentiometre();
			initialisation_bouton();
			if (sequence == null) sequence = "./sequence.xml";
			xml_chargeur.chargement_midi_xml(sequence, "sequence");
			initialisation = true;
		}
		// Initialisation des boutons (Retours par objets "Function")
		private function initialisation_bouton():void
		{
			bouton_jouer = new bouton(lutin_bouton_jouer, true, 0, action_bouton_jouer, action_bouton_dedans, action_bouton_dehors);
			bouton_stopper = new bouton(lutin_bouton_stopper, true, 1, action_bouton_stopper, action_bouton_dedans, action_bouton_dehors);
			bouton_stopper.visibilite(false);
			bouton_reculer = new bouton(lutin_bouton_reculer, true, 2, action_bouton_reculer, action_bouton_dedans, action_bouton_dehors);
			bouton_reculer.visibilite(false);
			bouton_avancer = new bouton(lutin_bouton_avancer, true, 3, action_bouton_avancer, action_bouton_dedans, action_bouton_dehors);
			bouton_avancer.visibilite(false);
			bouton_menu_haut = new bouton(lutin_bouton_menu_haut, true, 4, action_bouton_menu_haut, action_bouton_dedans, action_bouton_dehors);
			bouton_menu_valider = new bouton(lutin_bouton_menu_valider, true, 5, action_bouton_menu_valider, action_bouton_dedans, action_bouton_dehors);
			bouton_menu_bas = new bouton(lutin_bouton_menu_bas, true, 6, action_bouton_menu_bas, action_bouton_dedans, action_bouton_dehors);
		}
		// Initialisation des potentiomètres
		private function initialisation_potentiometre():void
		{
			potentiometre_volume = new potentiometre(0, 580, 680, lutin_bouton_volume, reglage_volume);
			potentiometre_tempo = new potentiometre(1, 430, 530, lutin_bouton_tempo, reglage_tempo);
		}
		// Fonction d'incidence du potentiomètre volume
		private function reglage_volume(valeur:int):void
		{
			volume_piano = valeur;
			lcd.message_lcd("VOLUME : " + volume_piano.toString(), 20)
		}
		// Fonction d'incidence du potentiomètre tempo
		private function reglage_tempo(valeur:int):void
		{
			valeur_tempo = valeur;
			lcd.message_lcd("TEMPO : " + sequenceur.calcul_tempo().toString() + "%", 20)
		}
		// Fonction d'incidence commune aux boutons (Souris dedans)
		private function action_bouton_dedans(index:int):void
		{
			if (!aide.etat_actif) return;
			var texte:String = new String("");
			switch(index)
			{
				case 0 : texte = "Jouer sélection"; break;
				case 1 : texte = "Stopper sélection"; break;
				case 2 : texte = "Supprimer dernière note"; break;
				case 3 : texte = "Effacer toutes les notes"; break;
				case 4 : texte = "Option suivante"; break;
				case 5 : texte = "Valider ou changer valeur"; break;
				case 6 : texte = "Option précédente"; break;
			}
			aide.apparition_aide(texte, 708, 49);
		}
		// Fonction d'incidence commune aux boutons (Souris dehors)
		private function action_bouton_dehors():void
		{
			if (aide.etat_actif) aide.disparition_aide();
		}
		// Fonction d'incidence du bouton jouer
		private function action_bouton_jouer():void 
		{
			if (mode_piano == MODE_SEQUENCEUR && sequenceur.donnee != null) sequenceur.demarrage_sequenceur();
			else if (mode_piano == MODE_ACCORD) accord.jouer_accord();
		}
		// Fonction d'incidence du bouton stopper
		private function action_bouton_stopper():void 
		{
			sequenceur.etat_actif = false;
		}
		// Fonction d'incidence du bouton reculer
		private function action_bouton_reculer():void 
		{
			var index:int = accord.supprimer_note();
			if (index >= 0)	marquage.gestion_point_note(false, index);
		}
		// Fonction d'incidence du bouton avancer
		private function action_bouton_avancer():void 
		{
			marquage.initialisation_point();
			accord.initialisation_accord();
		}
		// Fonction d'incidence du bouton menu vers le haut
		private function action_bouton_menu_haut():void 
		{
			lcd.option_plus();
		}
		// Fonction d'incidence du bouton menu vers le bas
		private function action_bouton_menu_bas():void 
		{
			lcd.option_moins();
		}
		// Fonction d'incidence du bouton menu valiser
		private function action_bouton_menu_valider():void 
		{
			lcd.option_valider();
		}
//		Evènement ----------------------------------------------------------------------------------------------------------------
		// Evènement relatif à la fin du chargement d'un fichier midi xml
		private function reception_midi_xml(e:Event):void
		{
			sequenceur.donnee = xml_chargeur.midi_xml;
			echo_chargement_xml(null);
			lcd.message_lcd("SEQUENCE OK", 20)
		}
		// Evènement relatif à la fin du chargement du fichier de configuration
		private function reception_configuration(e:Event):void
		{
			lcd.instrument = xml_chargeur.configuration;
			echo_chargement_xml(null);
			lcd.charger_instrument();
		}
		// Evènement relatif à la fin du chargement du catalogue des fichiers midi xml disponibles
		private function reception_sequence(e:Event):void
		{
			lcd.sequence = xml_chargeur.sequence;
			echo_chargement_xml(null);
			lcd.charger_xidi();
		}
		// Evènement relatif à la fin d'un chargement xml avec échec
		private function echo_chargement_xml(e:Event):void
		{
			lcd.message_lcd(xml_chargeur.echo, 20);
		}
		// Evènement relatif à la fin du chargement des fichiers sons
		private function reception_gamme(e:Event):void
		{
			sequenceur.gamme = chargeur_note.gamme;
			echo_chargement_son(null);
			initialisation_objet();
		}
		// Evènement relatif à la fin d'un chargement son avec échec
		private function echo_chargement_son(e:Event):void
		{
			lcd.message_lcd(chargeur_note.echo, 20);
		}
		// Evènement relatif au clic de la souris sur le clavier
		private function touche_enfoncee(e:Event):void
		{
			if (clavier.note_piano == -1) return;
			sequenceur.jouer_note_index(clavier.note_piano, 127, 0, 0, NOTE_SOURIS, 0);
			if (mode_piano == MODE_ACCORD)
			{
				accord.ajouter_note(clavier.note_piano);
				marquage.gestion_point_note(true, clavier.note_piano);
			}
		}
		// Evènement relatif au clic relaché de la souris sur le clavier
		private function touche_relachee(e:Event):void
		{
			sequenceur.stopper_note(NOTE_SOURIS);
			if (mode_piano == MODE_SEQUENCEUR) marquage.gestion_point_note(false, sequenceur.note[NOTE_SOURIS].point);
		}
		// Evénement relatif aux chargements d'instruments
		private function charger_note_instrument(e:Event):void
		{
			try {chargeur_note.chargement_serie_son(lcd.chemin);}
			catch (e:Error)
			{
				lcd.message_lcd("INSTRUMENT NON TROUVE", 40);
			}
		}
		// Evénement relatif aux chargements dde séquences xidi
		public function charger_sequence_xidi(e:Event):void
		{
			xml_chargeur.chargement_midi_xml(lcd.chemin, "xidi");
		}
		// Evénement relatif au controle du bouton stop
		public function controle_bouton_stop(e:Event):void
		{
			try {bouton_stopper.visibilite(sequenceur.etat_actif);}
			catch (e:Error) {}
		}
	}
}

Conclusion :


Il y aura ENCORE une suite

Codes Sources

A voir également

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.