Visual Studio,DevC++, EasyPHP,XAMPP,WAMP,SQLserver C,C++,C#, JAVA,ASP,PHP,HTML,Javascript,DHTML,.NET (Photoshop,Blend,Flash,...) ... et tout ce qui va avec ^^!
Voila enfin du code, j'ai enfin pu avoir un peu de temps libre pour restructurer mon code, y ajouter une bonne documentation et le proposer sur mon blog :) J'ai aussi reçu dernièrement plusieurs mails me demandant de fournir plus de sources, après mur réflexion , je vous avoue qu'il est beaucoup plus aisé de fournir un projet ou un package complet plutot que d'essayer de l'éxpliquer et de le detailler à travers plusieurs articles . Il fallait donc avant tout que mon code devienne lisible, facilement comprehensible, pour que d'autres developpeurs puissent y touché sans trop de soucis :)
le projet est structuré comme tout projet de dev en plusieurs repertoires:
- un repertoire src : contenant les fichiers sources - un repertoires classes : contenant les fichiers binaires (apres compilation) - un repertoire ressource : contenant les resources images et sons necessaires à la compilation et enfin, un repertoire doc : contenant la documentation necessaires à la bonne lisibilité du code.
Voila donc, le projet complet est téléchargeable ICI , ah , j'ai oublié un truc... le truc le plus important... Avant de vous incitez à y jouer , je vous incite d'abord à y toucher ^^ :) ne vous inquiétez pas trop ... quand vous lancerez votre première partie vous comprendrez rapidement ce que j'essaye de vous dire par la =)
Et pour finir et histoire de vous donner l'eau à la bouche ..., je vous propose cette petite démo ...
Ah avant que j'oublie, et avant de vous laisser partir tapoter sur vos petits claviers , faut que je vous dire un truc "Happy new year everybody ...especialy developers =) "
ps 1: ce jeu est encore en révision , il reste encore des fonctionnalités à coder, j'y reviendrai quand j'aurai un petit peu plus de temps ^^ :)
ps 2: à voir aussi : lancement d'un incubateur d'entreprises TIC au Cyberparc de Sidi Bouabdallah :)
Chers Amis informaticiens , plus particulièrement ceux résidants en Algérie, le monde des startups et des idées libres vous appelle =)
j'ai discuté dernierement avec mon ami KT, et il m'a alors informé de l'organisation d'un concours destiné aux jeunes developpeurs, passionés d'informatique ou autres jeunes entrepreneurs Algériens . je vous fait donc parvenir l'annonce :
A l’occasion du lancement du premier incubateur d’entreprises TIC en Algérie en janvier 2010 au Cyberparc de Sidi Abdallah, un concours pour la création d’entreprises TIC (startups) sera organisé.
Les 20 meilleurs projets sélectionnés seront hébergés gratuitement dans des espaces de bureau world classe et équipés à l’incubateur du Cyberparc de Sidi Abdallah et bien d’autres avantages : financement, accompagnement spécifiques et un coaching adapté par des experts ...etc.
voila, et pour plus d'informations je vous conseille d'aller jeter un coup d'oeil ici
Bon, histoire de prendre un peu de recul par rapport à la série de Tuto java sur le jeu d'échec, j'ai en quelque sorte changé de stratégie parce qu'au rythme ou ça avance il me faudra au minimum une vingtaine d'article pour tout expliquer.
Donc, je me suis simplement posé la question ; pourquoi ne pas fournir directement mes sources en leurs ajoutant une documentation de qualité , en tout cas, c'est ce que je suis en train de faire en ce moment et en attendant un dernier article récapitulatif infesté de codes sources ^^ et parsemé de commentaires je vais me permettre de m'étaler un petit peu plus sur un autre travail sur lequel je bosse toujours o-o !
je travaille actuellement dans le cadre de mon projet ECAO au département ASI de l'INSA de Rouen sur un projet d'interconnexion de deux systèmes d'information , celui du département et celui de l'INSA.
Une bonne partie des données utilisées par le département provient du SI de l'INSA , sauf que ces données étaient fournis avant sous format xml. Et que leurs exploitation se faisait à travers un serveur Apache-cocoon2 . Voilà, vous avez sans doute remarquer que cela nous laisse de la marge quand à l'automatisation de cette tache. Je m'explique :p
Ce projet consistait au début à proposer une vue des données utilisée par le département au DSI de l'INSA , et de programmer les pipelines cocoon nécessaires à l'interrogation direct de la base à travers ces mêmes vues , on n'aura donc plus à transiter par du xml statique ! Intéressant , non^^?
Un tel projet nécessite forcement une phase de test, puisqu'il existe une interaction entre plusieurs technologies ( Gestionnaire de base de donnée , programmation et configuration des pipelines...ect),
j'ai du alors avant de commencer à bosser dessus faire plusieurs choix quand aux technologies utilisées, plusieurs recherches sur internet ont été nécessaire et comme après chaque recherche je me pose toujours la même question: mais pourquoi personne n'a jamais pensé à rédiger un et un seul article assez détaillé sur tel ou tel truc pour ne pas qu'on ai toujours à basculer d'un site à un autre rien que pour savoir comment implémenter ceci ou comment utiliser telle ou telle librairie . Et c'est uniquement pour cette raison que j'ai voulu exposer ma démarche à travers cet article.
Pour ce qui est de la phase de test, On doit obligatoirement passer par plusieurs étapes :
L'élaboration de schéma xml et d'une modélisation UML ( il n'y a pas une réelle nécessité de détailler cette partie , puisqu'elle sert surtout à proposer un accès aux données, sauf que nous, pour cette phase de test, nous allons plutôt généré ces données à travers le fichier XML fournis et programmer les pipelines cocoon nécessaires à l'exploitation d'une base et non d'un fichier XML.
Les choix se sont finalement portés sur :
mySQL comme gestionnaire de base de données:
Java, plus particulièrement JDOM comme langage me permettant de parser mon document XML , et d'alimenter ma base.
SQLTransformer et XSP / ESQL afin de tenter deux approches permettant la
programmation de transformateurs sous cocoon2.
Commençons tout d'abord par une problématique assez simple , commet à partir d'un fichier XML , pourra-t-on alimenter une BDD? Une idée^^?
Si je vous dis JDOM ? Ça vous dit quelque chose, JDOM est une librairie java très puissante qui vous permet de parser votre document XML et d'avoir ainsi accès à tout les nœuds sans avoir vraiment à gérer une grosse arborescence , il est aussi possible d'utiliser DOM : mais bon, pour éviter toute la complexité que cela peut engendrer (génération d'une grosse arborescence regroupant tout les nœuds et j'en passe), j'ai plutôt opté pour JDOM.
Vous pouvez télécharger la librairie JDOM en cliquant ici .
Aussi et vue qu'on devra établir un programme java qui se chargera en plus du fait de parser notre document XML de remplir systématique notre BDD , nous devons aussi installer MySQL
je vous propose pour cela de taper dans votre terminal les deux lignes de commande suivantes :
et comme fichier source quoi de plus interessant pour cette premiere phase de teste qu'un simple fichier XML regroupant des nœuds dépendant d'une racine et possédant des attributs : on aura donc à gérer à travers ce petit exemple tout les types de donnée composant un fichier XML,
arbre du fichier xml :
etudiants
------->etudiant(attribute:nom="toto")
-----classe=CM1
------->etudiant(attribute:nom="tata")
-----classe=CM2
testons alors ensemble cette phase de remplissage …
vérifiez juste après l'exécution du programme java que votre table a bien été créé et qu'elle contient tout ce que le fichier XML contenait comme information. Si ce n'ai pas le cas revoyez votre code^^ ...
une remarque par rapport à l'exécution du programme java remplissageBDD
Passons maintenant à la deuxième partie du projet , la plus excitante^^ ! nous disposons maintenant d'une base de données contenant toute les données nécessaires à la génération de nos pages :
comment faire alors pour véhiculer ces donnés et les présenter sous format html .
Cocoon -apache 2 est le serveur par excellence pour ce genre de tache , avant de commencer , je vous conseille d'aller jeter un petit coup d'œil sur le site officiel cocoon-apache.
La transition de ces données sous cocoon se fait à travers des pipelines ; un pipeline ce n'ai ni plus ni moins qu'un chemin programmé, contenant trois modules :un module de génération, un autre de transformation et un dernier qui se charge de la séréalisation et qui permet de modifier les données en fonction de leur usage.
Vous vous posez surement la même question que moi au départ ^^ ,je me disais tout le temps : 'Des serveurs j'en ai vu tellement , de toutes sortes en tout cas en partant d'IIS jusqu'au Jboss, Tomcat, apache et compagnie..mais à aucun moment je n'ai eu affaire à un pipeline ou un truc du genre
c'est quoi donc finalement cette histoire de pipeline? Ne vous inquiétez pas aussitôt cette phase de test fini vous y verrez beaucoup plus clair pour tout ce qui concerne cocoon et ses pipelines ^^
ajoutez entre deux blocs 'pipeline' un bloc 'map:match' contenant une generateur 'map:generate' un transformateur 'map:transfort' et un séréaliseur 'map:serealize' ...
Le premier blocs sert à définir l'url qui pointera directement vers votre pipeline.
Les générateurs et les transformateur auront besoin comme source d'un fichier; un fichier de base. xml par exemple pour la génération et xslt comme fichier de transformation.
Par contre on aura surtout besoin lors de la serialisation de définir un type. Un format de sortie; xml ou html par exemple.
Pour configurer de pipeline je vous conseille fortement d'aller voir du coté du site officiel apache-coccon 2 , vous y trouverez plusieurs exemples .
J'ai du dans mon cas, définir une connexion à ma base dans mon cocoon.xconf et faire référence à ma connexion en ajoutant à mon transformateur un paramètre nommé use-connexion et qui pointe sur la connexion préalablement établie.
Attention , plusieurs approches restent possible. J'en ai testé deux : une en utilisant SQLTransformer et une autre sur la base d'un fichier xsp ...je ne vous cache pas que ma préférence va plutôt vers xsp . XSP vous laisse beaucoup de marge quand à votre présentation … tout est inclus dedans ^^ au grand bonheur des cocooniens :)
Le constructeur définie lors du précédent tutoriel , nous permet de générer la grille suivante , sans les icones bien sûr , je vais vous détailler sur ce tuto les deux fonctions permettant la génération de ces icones sur cette grille ...
Avant de passer aux fonctions d'initialisation , je reviens un peu en détail au précédent constructeur , en précisant que notre classe DisplayingTable herite de la classe mere Jframe , et qu'aussitôt une instance généré , son constructeur se charge de récupéré une référence vers le Container de cette page et d'y ajouter a la fin notre Jpanel surchargé d'éléments de jeu,
l'allocation du GridBaglayout s'est faite alors sur le Jpanel tables pour que table puisse être ajouter au Container.
Revenons maintenant à l'initialisation de nos éléments de jeu , deux fonctions ont été nécessaire à cela :
la classe initialisation , qui se charge d'importer une icône définissant chaque élément de jeu , en spécifiant comme paramètre , le chemin vers l'icone en String , et les coordonnées de l'élément auxquels elle devra être affecter .
public void initialisation(String url_file,int i,int j)
tachez pour l'instant de ne pas trop vous focaliser sur les lignes de commandes permettant d'ajouter des listener à nos objets . Cette fonction d'initialisation , créer à chaque appel un nouvel objet lui alloue comme couleurs , la couleur de la case correspondante , et la on remarque l'utilité de la création d'un tableau de couleurs ,cette mémorisation s'avère donc être utile :) !
on supprimera par la suite l'élément visé à travers les coordonnées donnée en paramètres , cela bien sur afin de le remplacer par le nouvel élément instancié.
Cette fonction à été surtout crée pour être soliciter à travers plusieurs appels, par une fonction appelons la mere ^^ , qui initialisera tout les éléments du jeu :
public void ElementsInitialisation()
{
for(int i=0;i<8;i++)
{
this.initialisation("pion_blanc.gif",i,1);
}
for(int i=0;i<8;i++)
{
this.initialisation("pion_noir.gif",i,6);
}
this.initialisation("tour_blanche.gif",0,0);
this.initialisation("tour_blanche.gif",7,0);
this.initialisation("fou_blanc.gif",2,0);
this.initialisation("fou_blanc.gif",5,0);
this.initialisation("chevalier_blanc.gif",1,0);
this.initialisation("chevalier_blanc.gif",6,0);
this.initialisation("reine_blanche.gif",4,0);
this.initialisation("roi_blanc.gif",3,0);
this.initialisation("tour_noir.gif",0,7);
this.initialisation("tour_noir.gif",7,7);
this.initialisation("fou_noir.gif",2,7);
this.initialisation("fou_noir.gif",5,7);
this.initialisation("chevalier_noir.gif",1,7);
this.initialisation("chevalier_noir.gif",6,7);
this.initialisation("reine_noir.gif",3,7);
this.initialisation("roi_noir.gif",4,7);
}
la fonction ,ElementsInitialisation initialisera à travers plusieurs appels à la précédente fonction tout les éléments de jeu , tachez juste de mettre les bonnes coordonnées et à ne pas vous trompez lors de la spécification du chemin relatifs à chaque icône .
Voilà, pour cette toute première partie graphique, on développera dans les prochains tuto, l'utilisation de nos Listners pour en quelques sorte dynamiser ce graphisme... vous aurez aussi bien affaire aux classes du package Bakend qu'a ceux de EventHandlers … :p
Hola los amigos ^^ , je vous rassure je me sent très bien aucune séquelle mental pour l'instant , que du plaisir c'est juste que je me suis mis à l'Espagnol , formation oblige =) ...aller, sans plus tarder
je vais commencer à exposer ce que contient ce fameux package graphique. Et c'est sans vous dire que nous allons traiter des tas de nouveaux concepts...
Avant de construire n'importe quel chose , nous aurons bien besoin d'outil , fini les temps des pharaons ou on soulevais des pierres de plusieurs centaine de Kilo en utilisant des moyens dérisoires,
ma table de jeu aura bien besoin d'outils permettant une intégration facile des éléments de jeu,
Avant de parler d’outils, on va commencer tout d'abord par expliquer en quoi consiste cette grille de jeu, une grille assez simple, contenant un Jpanel auquel nous avons définie un GridBagLayout,
je tiens à signaler qu'avant d'appliquer un GridBagLayout , j'ai fait quelques tests non concluant en utilisant un GridLayout , conclusion tiré , le GridBagLayout offre plus de flexibilité quand au positionnement et à la récupération de ses éléments .
Pour ajouter un élément à un GridBagLayout nous aurons forcement besoin d'un GridBagConstraints, qui nous permet de définir les contraintes relatifs à chaque élément (coordonnée sur la grille : gridx,gridy et nombre de case concernée :gridwidth,gridheight)
et c'est la que la définition d'un premier outil graphique s'est imposé , nous auront tellement d'éléments à gérer qu'il sera totalement bourrin le fait de modifier les paramètres de ces contraintes chaque ajout, ma Class DisplayingTools contient donc une fonction , GridBagTransformer qui prend comme paramètre mon GridBagConstraints , aussi bien que les valeurs des éléments à assigner à chacun de ses paramètres , se charge ensuite de les modifier et de retourner l'objet prêt à être utiliser lors du prochain ajout :
public GridBagConstraints GBTransformer(GridBagConstraints GridBagCInput,int x,int y,int px, int py)
{
GridBagCInput.gridx=x;
GridBagCInput.gridy=y;
GridBagCInput.gridwidth=px;
GridBagCInput.gridheight=py;
return GridBagCInput;
}
Enfin, et pour illustrer l'utilisation de cet outil , je vais devoir passer à la classe DisplayingTable , sur laquelle la grille aussi bien que tout les éléments de jeu sont instanciée et ajouté.
Chaque case de ma grille aura forcement besoin d'un élément définissant aussi bien sa couleur qu'éventuellement l'icone (pion, tour, cheval , reine ...etc. ) désignant l'élément présent. Nous opterons alors pour des Jlabel , ce qui nous évitera d'avoir a chaque fois à dessiner un rectangle et d'y ajouter une icône ,
Nous aurons donc à initialiser les éléments suivant :
le premier tableau labes contient tout les éléments à ajouter à chaque case de notre Jpanel,
notre Jpanel a été initialisé juste en dessous,
le tableau Colors, nous permet d'avoir en mémorisation la couleur de chaque case. Enfin et en dernier , nous avons définie nos deux éléments GridBagConstraints GBC et TransformerTool qui vont nous aider en quelque sorte à ajouter nos éléments d'une manière assez soft .
Notre constructeur, DisplayingTable se chargera donc d'initialiser chaque élément , de modifier notre GBC à travers l'outils définie précédemment pour au final l'ajouter à notre Jpanel table :
le raisonnement est assez logique , on initialise à chaque fois un nouveau Jlabel, on lui assigne une couleur , en faisant en sorte à travers une variable booléenne commute , de générer un effet de commutation ,donnant ainsi à la grille la distribution exacte en jeune et vert :
premiere ligne : jaune – vert -jaune – vert ... ect
deuxieme ligne : vert- jaune -vert- jaune ... ect
pour à la fin ajouter chaque element à la table .
Je vous laisse un peu de temps pour vous imprégner de tout ça, de toute façon j'y reviendrai sur mon prochain tuto... ;)
Plusieurs mois déjà que je n'ai plus posté sur mon blog, la raison est toute simple ; J'ai carrément changé de cap et ma vie à pris une autre tournure , j'avais postés mes tout derniers articles en étant Ingénieur développeur dans une société de service en informatique , sauf que la , je me présente sous une autre forme : Elève ingénieur en Architecture des systèmes d'information à l'Institut Nationale Des Sciences Appliquées à Rouen. Eeh ouii , la nécessité d'avoir une formation dans le domaine, de m'améliorer techniquement ,d'atteindre une certaine aisance dans la conception et le codage ... tout ces paramètres m'ont poussé à aller tenter cette expérience ... la , j'en suis à mon tout deuxième mois et je vous avoue que je suis plus que satisfait :)
j'essayerai en tout cas de vous donner plus de détails lors de mes prochains posts , Dès mon arrivé et aussitôt installé , je me suis de suite dirigé vers mes enseignants , mes camarades de promo pour prendre connaissance des projets qui se faisaient au département , des différentes technologies qu'on enseignait , et aussi ce qui m'importait le plus , les projets perso ,car on a l'habitude de voir chez certains passionnés de l'informatique , en plus de leurs petit boulot de développeur ou de leur formation , qu'il ont l'habitude de bosser pendant leur temps libre sur de petit projet (ça peut aller des jeux jusqu'aux grosses applications qui leurs facilitent leurs quotidiens) Je vous rassure , je n'échappe nullement à cette règle =D ! ,
En faisant mes premiers pas dans ce nouveau monde linuxien, la ou toutes les exceptions ne peuvent être que sous forme « CodeOverdoseException » et ou un multithreading d'action et d'initiative s'impose ^^… je me rends de plus en plus compte de l'importance et surtout du plaisir qu'un bon projet de développement peu aporter.
Je reviens donc sur ce blog avec de nouvelles idées, je viens de me lancer depuis déjà presque deux semaines dans un petit projet qui me tenais à cœur, la conception et le codage complet d'un jeu d'échec :P ! Mon objectif ne se résume pas simplement au fait que mon jeu fonctionne , plus que ca , je vise surtout à élaborer un codage assez optimisé, et à bien architecturé mon jeu (packages , codage en couches ..etc.)
Avant de commencer je tiens à répondre aux quelques mails que j'ai reçu me demandant la suite des tutoriels sur la fameuse bataille navale que j'avais codé … je vous signal qu'un petit souci technique :( formatage d'une partie de mon disque m'a fait perdre , une petite partie des fonction que j'avais coder coté serveur , aussitôt ces tutoriels terminé, je reviendrai à la charge pour poursuivre cette première série sur la bataille navale ;)
Autre chose ,actuellement, je travaille toujours sur ce jeu d'échec , pour l'instant j'ai réussi en deux semaines , à définir mon environnement de jeu , l'évolution de chaque pièce indépendamment des autres sur cet environnement et je m'apprête à présent , à implémenter mes fonctions d'interaction sur un package conçu spécialement pour ça « VirtualGame Package»
La réalisation de ce jeu passe forcement par plusieurs étapes ;
- conception d'une plateforme de jeu locale fonctionnant en mode deux joueurs - codage et déploiement de modules ( logique suivie : couche graphique , couche métier et couche interaction) - Elaborer des algorithmes d'IA afin d'implémenter des modules AP (AutonomousPlayer) - Tests de validation et mise en ligne.
Ce projet peut donc être deviser en deux parties , Je commencerai tout d'abord par la toute première partie ou on devra concevoir une plateforme de jeu à deux joueurs , la deuxième partie sera beaucoup plus pointu … nous y reviendrons en temps voulu;
Pour l'instant place au code , je ne vais pas commencer à vous gaver par des diagrammes UML , de schéma que vous aller fixé pendant des heures afin d'y comprendre un minimum , je vais plutôt vous proposer une conception assez soft ,suivant le fameux principe KISS (Keep it Simple ,Stupid) …
On a quand même bien philosophé sur la question , place maintenant au code :P … l'implémentation des différentes fonctionnalités (classes , méthodes) s'est faite en respectant le principe du développement en couche , en réalité , tout a été réparti en package avec pour chaque couche une série de package , je vous propose donc l'arborescence actuelle du jeu :
Contenue en classes et méthodes de chaque package :
graphique-DisplayingToolP
- DisplayingTools Class contenant une fonction GridBagTransformer : gere dynamiquement l'emplacement des éléments sur ma GridBagLayout - menuBar Class: contenant une seul fonction qui génère l'arborescence du menu - DisplayingTable Class : contient des fonctions d'initialisation : - initialisation (initialise chaque élément de jeu) - ElémentsInitialisation , de porté plus général que la précédente , elle initialise tout les éléments de jeu - DisplayTable (constructeur) : création des éléments graphiques
graphique-Display
ChessFrame Class : qui se charge de la visualisation de la table de jeu.
métier-EventHandlers
ChessterEvent Class : gère les événements émanent des différents éléments graphique du jeu.
metier-Backend
Plusieurs classe définissant chaque élément de jeu : pion,tour,fou,cheval,roi et reine , on y trouve aussi l'interface pièce implémenté par chaque élément.
metier-VirtualGame
BackendGame Class : se charge d'initialiser sur une grille tout les éléments de jeu, objets pièces s'initialisent suivant la nature de l'objet (pion , tour , fou...etc.).
Voilà , je vais m'arrêter la pour ce premier tutoriel , j'espère que cela vous a au moins permis de vs imprégner assez facilement du raisonnement suivie , … je vous invite dés maintenant à suivre le prochain tutoriel , Ah ,oui ,j'ai oublié de vous dire un truc , n'hésitez surtout pas à laisser vos coms , vos suggestions , parce que ce jeu on va le faire à plusieurs, je vous propose cette série de tutos alors que je travaille toujours dessus , donc , je résume , prochain tuto avec pour thème : package graphique :code et test … :P
J'ai travaillé recement sur une application mobile fonctionnant sous Windows CE 5.0 . Mon souci était celui d'imaginer une solution capable de gérer un référencement détaillé alimentant un historique d'utilisaiton à partir d'un simple événement scan !
Techniquement j'avais la possibilité de le faire en C#.NET à travers un projet Smart device sous Visual Studio 2008, mon code se résumait alors à instancier des objets chargés de prendre en consideration la gestion du transfert des fichier entre mon Datalogic et mon PC fixe. En Gros j'avais affaire au Windows CE mobility device et à une librairie spécifique au transfert de fichiers, L'idée qui m'est venu était simple , je vais vous expliquer en quoi consistera le plus gros de mon travail , si par exemple vous aurez à travailler sur une application pareille vous allez investir une bonne partie de votre temps à charcher les bons fichier assembly (DLL) et à tester leurs incorporation et leurs exploitation dans votre code.
Je vais commencer tout d'abord par vous donner un apercu sur cette panoplie d'outil à laquelle j'ai eu affaire , Vu que vous en aurez plue que besoin , je vous propose tout d'abord de télécharger la DL Mobility Developer Assistant for VS 2005 . sur cet assistant , vous trouverez des exemples en code des differentes fonctions offertes.Le kit de developpement mobile contient une panoplie de fichier dll necessaire à vos développement sur Datalogic à travers Windows CE:Bluetooth.dll, Powermanag2005.dll, Gsm2005.dll,Device2005.dll , pour mon application j'avais surtout eu besoin du Datacapture.dll et du Pdc.dll.
En gros je devais enregistrer les codes scannés en fonction de certains cretères de scan , donc j'avais besoin d'instancier un objet Lazer pour programmer ma fonction GoodRead , Appllée par l'evennement Scan
Aussi pour ce qui est des transferts de fichiers , j'avais surtout besoin de la librairie Communication qui prend en consideration toutes les communications qui peuvent s'établir entre PDA et Desktop PC , donc apres avoir incorporer le fichier assembly: OpenNTFC.desktop.comunication.ddl j'avais instancié un objet RAPI qui prend en consideration les connexions établis à travers ActiveSync.
Cet Objet et comme tout autre objet de lecture , sur peripherique externe ou sur base de donnée, necessitait l'ouverture d'une connexion avant l'éxécution d'une lecture , ecriture ou d'une modification , ainsi qu'une deconnexion aussitôt ces fonctions exécutées.
J'ai finalement utilisé les deux fonctions : CopyFileFromDevice() et DeleteDeviceFile() qui se chargent du trasfert sur Desktop,
J'ai publié ces quelques astuces sur article afin que vous n'aillez plus à vous balader sur des dizaines de forums à la recherce des bonnes librairies necessaire au developpement de votres application sur Datalogic.
Vu que c'est ma derniere année d'étude et que j'aurai à présenter mon projet de fin d'étude courrent cette semaine , ...je vous avoue que je stresse un peu , il parrait que c'est normal^^ mais bon , c'est seulement pour vous dire que je me consacrerai beaucoup plus à ce blog aussitôt cette présentation faite.
Google summer of code , voila le nom de ce programme, ça a été lancé récemment par google et le principe est assez simple , vous vous débrouillezpas mal en code , vous avez une passion pour le développement , google se charge alors de vous trouver un stage sur le net à partir de chez vous , Ils jouent le rôle d’intermédiaire entre vous et la boite pour laquelle vous aller développer votre solution Des gars de différents coins de la planète y participent et c’est sans vous dire qu’au finale vous aurez et une expérience, celle d’avoir travaillé sur un projet internationale et d’avoir été orienté par des développeurs de renom et une bonne rémunération, vous voulez des chiffres attention les yeux parce que je vais vous en donner, 4000$ ca vous dit, 6000$ non, toujours pas ^^ ! Non, mais c’est pour vous dire que si vous êtes passionné et que vous êtes prêt à passer le plus gros de votre temps en été devant votre PC à basculer de votre code à votre encadreur sur skype, inscrivez vous dès maintenant. Ou plutôt pour la prochain édition, car les inscriptions pour l’édition 2009 sont closes. Donc vous savez ce qui vous reste à faire, déjà pour commencer allez jeter un petit coup d’œil du coté du site officiel de Google Summer Of Code http://www.code.google.com/soc . Je vous conseille aussi d’aller consulter les pages des précédentes éditions de GSOC, par exemple pour 2006 vous trouverez ICI Une liste d’organisations de monitoring ayant proposé leurs services à travers Google summer of code. La liste de celle retenue pour l’édition 2009 a été publié http://socghop.appspot.com/program/accepted_orgs/google/gsoc2009 Aussi, et pour que vous puissiez juger de l’énormité de ce truc je vous propose cette séquence animé par un mentor de GSOC,
Alors , génial ,nn ? :D
Aussi, plusieurs fondations de logiciels open source participent à ce programme, les rémunération se font par rapport à l’état d’avancement du projet , je trouve que c’est normal parce qu’on ne peut juger du niveau d’un développeur qu’a partir de l’état d’avancement de son projet, et pour que vous mettiez toutes les chance de votre coté je vous conseille d’entrer en contact avec ces boites qui proposent des services de monitoring histoire d’avoir une idée sur la procédure à suivre pour avoir le bon projet qui correspond le mieux à vos compétences …n’hésitez pas trop , vous avez entendu ce qu’a dit le gars , pas besoin d’être un génie pour réussir à faire un truc intéressant dans ce programme , l’envie d’apprendre de partager une expérience professionnelle de haut niveau suffit :D, en plus du fait que ça fera tout JOLI sur votre CV , rendez vous en 2010 pour la prochaine édition …
Du nouveau, Oui, je reviens à vous avec du neuf, concernant quoi ?, … n’allez pas chercher bien loin, je vous l’avez promis … ouvrez bien vos oreilles : « The Navale Ballte : design , conception & codage en C# » Eh oui , on y est , ceci est donc le premier Tuto d’une série d’articles que je présenterai au fur et a mesure que je les préparerai.
Je ne vais pas non plus m’attarder à vous expliquer la philosophie de mon développement, donc, je vais essayer de faire le plus simple et le plus directe possible :D ,
A vos clavier donc, je vais commencer par introduire les couches que j’ai implémenté dans mon projet , ne soyez pas impressionné par ce mot , développer en couche ou en module vous offre plus de facilité ,une meilleure organisation de votre code et une plus grande efficacité d’intervention face aux bugs et aux éventuels problèmes.
Donc, en gros il y a mon application, c'est à dire mon jeu qui peut être lancé par n’importe quel utilisateur en vue de faire une partie et il y a le serveur qui se charge de synchroniser mon mode multi-joueurs, et pour que vous suiviez mon raisonnement je vais commencer par la partie serveur, les variables qui y sont définie et les fonctions de synchronisation que j’ai implémentée.
J’essayerai de détailler au maximum mon code, donc vous aurez des fois l’impression que
Je prendrai mon temps à expliquer les parties disons les plus compliquer même s’il n’y a rien de compliquer dans tout cela :D
Voici les variables que j’ai définie dans ma classe service, juste une petite remarque, les variables que j’ai définie en private ne sont accessible qu’a partir des fonctions de la même classe donc, pas a partir de mon applicatif coté client, ceux en static auront la particularité de
De rester statiquement modifiable par mes fonctions serveur , je sais ce que vous vous dite , mais c’est quoi ce truc de « statiquement modifiable » logiquement ; on ne peux modifié le statique et le modifiable ne peut pas être statique o_O ! , en réalité un objet statiquement modifiable restera statique jusqu'à sa prochaine modification pour ceux qui connaissent les principes du bistable par rapport au mono stable comprendront beaucoup plus facilement
private boolP1_play = false;
private boolP2_play = false;
private stringP1_coup = "";
private stringP2_coup = "";
static private boolP1_connection = false;
static private boolP2_connection = false;
static private boolP1_update = false;
static private boolP2_update = false;
static private string[] P1_B1 = new string[4];
static private string[] P1_B2 = new string[3];
static private string[] P1_B3 = new string[3];
static private string[] P1_B4 = new string[2];
static private string[] P2_B1 = new string[4];
static private string[] P2_B2 = new string[3];
static private string[] P2_B3 = new string[3];
static private string[] P2_B4 = new string[2];
Et comme vous voyez dans cette première potion de code j’ai définie six variables logiques. Les deux premières me permettrons de définir l’état ou disons rôle de chaque joueur, s’il a déjà joué, ou s’il a la main pour joué.les deux autres P1 & P2 connexion servent à définir le statut de chaque joueur (connecté ou non connecté) par rapport a la partie en cours. Et enfin les deux dernières celles de l’update qui permettent de connaitre si le joueurs a fournis ou pas toutes les informations nécessaire au lancement de la partie.
La question qui se pose maintenant, c’est comment faire pour animer tout cas, la je vous dirai « FONCTION » et je vais vous illustrer les quelques fonctions que j’ai développé coté serveur et qui me permettent de synchroniser ma partie.
public string allow_player()
public void play(string nb_player,string coup)
public string[] upload_position(string nb_player)
public void player_update(string nb_player,string pos1,string pos2,string pos3,string pos4)
Donc pour ce premier Tuto je vais faire tout simple et je vais commencer par ces 5 fonctions que je commenterai au fur et à mesure que je montre mon code.
Update_player , tout est dans sa définition :D , chaque joueurs sollicitera cette fonction avant de se mettre en état « je suis prêt a lancer ma partie » et cela permet d’updater les positions de ces quartes bateaux sur cette classe coté serveur , donc , après lancement de la partie chaque joueurs aura une grille caché , et elle n’aura qu’un seul truc a cacher cette grille , les positions des bateaux de son adversaire.
public void player_update(string nb_player,string pos1,string pos2,string pos3,string pos4)
{
if (nb_player=="P1")
{
P1_B1[0]=pos1.Substring(0,2);
P1_B1[1]=pos1.Substring(2,2);
P1_B1[2]=pos1.Substring(4,2);
P1_B1[3]=pos1.Substring(6,2);
P1_B2[0]=pos2.Substring(0,2);
P1_B2[1]=pos2.Substring(2,2);
P1_B2[2]=pos2.Substring(4,2);
P1_B3[0]=pos3.Substring(0,2);
P1_B3[1]=pos3.Substring(2,2);
P1_B3[2]=pos3.Substring(4,2);
P2_B4[0]=pos4.Substring(0,2);
P2_B4[1] = pos4.Substring(2, 2);
P1_update = true;
}
else
{
P2_B1[0]=pos1.Substring(0,2);
P2_B1[1]=pos1.Substring(2,2);
P2_B1[2]=pos1.Substring(4,2);
P2_B1[3]=pos1.Substring(6,2);
P2_B2[0]=pos2.Substring(0,2);
P2_B2[1]=pos2.Substring(2,2);
P2_B2[2]=pos2.Substring(4,2);
P2_B3[0]=pos3.Substring(0,2);
P2_B3[1]=pos3.Substring(2,2);
P2_B3[2]=pos3.Substring(4,2);
P2_B4[0]=pos4.Substring(0,2);
P2_B4[1]=pos4.Substring(2,2);
P2_update = true;
}
}
Je vous disais que la fonction update sert à faire parvenir les positions a ma classe coté serveur Pour que chaque joueurs puisse les updater, une deuxième fonction a été élaborer la fonction upload_posision , et la vous remarquez que les position sont retourner sur un tableau de string , donc , je les envoie en chaine de caractère et pour les exploiter coté joueur j’effectue une dé-concaténation et cela m’évitera bien sur d’entrer à chaque fois dans l’exécution de plusieurs boucles for(…) if()….else….
Je continue alors avec mes fonctions, il en reste deux pour ce premier tuto , les fonctions , play et Allow_player, la fonction Play est sollicité a chaque coup dans la partie , elle informe chaque joueur sur son tour, s’il doit jouer ou s’il doit attendre le cout de son adversaire.
Et cela a travers les deux variables que j’ai définie précédemment, P1_play et P2_play
public void play(string nb_player,string coup)
{
if (nb_player == "P1")
{
P1_play = true;
P2_play = false;
}
else if (nb_player == "P2")
{
P2_play = true;
P1_play = false;
}
}
Et pour finir une dernière fonction, que n’était présente dans mon code, mais que j’ai préféré implémenté pour que ca fasse plus propre et que mon code soit bien compréhensible
Une fonction de ce genre vous sera surtout utilise si vous travailler sur une plus grosse application serveur , genre un serveur qui supporte 5,10 voir plus de 20 joueurs , la vous devrai allouer un état a chaque joueur , or , dans mon code la , je ne fais que fournir deux information , quel joueur s’est connecté et quel est son statue par rapport à la partie qui vas se lancer « P1 » ou « P 2 » imaginez un peu ce que cela risquerai de donner comme fonction dans le cas ou je travaille avec 10 joueurs en même temps. Je sais que ca vous excite tout ca ,ben , ne vous en faite pas , aussitôt que je terminerai ces premier tutos ou je vais montrer le plus gros de mon code on redéveloppera ensemble ce même algorithme pour une charge minimale de 10 utilisateurs :D , j’ai ma petite idée sur la manière la plus optimale de le faire ;)
Et si vous vous encore une fois revoir à quoi ça va ressembler à la fin , c'estICI que ça se passe :)
Voila enfin du code, j'ai enfin pu avoir un peu de temps libre pour restructurer mon code, y ajouter une bonne documentation et le proposer sur mon blog :)
