Welcome to Bukkit France

Inscrivez-vous maintenant pour profiter d'un accès total à tout le contenu offert par la meilleur communauté Bukkit française ! Une fois inscrit et connecté, vous pourrez contribuez à la communauté en postant vos propres sujets et questions ou en répondant à ceux existants. Vous pourrez aussi customiser votre profil, recevoir des points de réputations, communiquer avec les autres membres via le chat, et plus encore! 

  • Annonces

    • Pskyco

      Bukkit France passe sous Discord !   02/20/16

      Bukkit France est désormais passé sur Discord, au revoir donc notre vieux Teamspeak ! Téléchargez le client et venez nous rejoindre sur notre salon en suivant les instructions suivantes.
      M-à-j du 25/02/2017 : Désormais, seuls les comptes actifs sur le forum se verront donner l'accès au Discord, ce dernier n'est pas une plateforme d'aide de la même manière que le chat.

Blogs

Billets mis en évidence

  • Pskyco

    Bukkit France passe sous Discord !

    Par Pskyco

    Edit du 25/02/2017 : Désormais, seuls les comptes actifs sur le forum se verront donner l'accès au Discord, ce dernier n'est pas une plateforme d'aide de la même manière que le chat.

    Bonjour,   Nous vous écrivons ce petit billet afin de vous annoncer que Bukkit France passe sous le client VoIP Discord qui offre des services plus que convenables !   Cette envie de changer de plateforme s'est manifestée grâce aux nombreux avantages qu'offre Discord. L'accessibilité directe depuis le navigateur est d'ailleurs l'une des raisons principales.   Vous pouvez vous procurer Discord sur de nombreux systèmes,            Pour nous rejoindre, rien de plus simple, cliquez sur l'image ci-dessous et attendez qu'un membre du staff ne vous attribue le grade "Vérifié", vous permettant de parler librement avec les autres. Nous demandons un minimum d'une semaine d'ancienneté sur le forum et 20 messages pour y être accepté. En effet le Discord Bukkit.fr n'est pas une communauté à part mais bel et bien une extension de Bukkit.fr.     Nous vous attendons très nombreux !   Bien à vous, l'équipe Bukkit France
    • 7 commentaires
    • 2954 vues
  • while(true);

    Chapitre II : Les variables

    Par while(true);

    Une variable permet de stocker en mémoire une valeur d'un typé donné. On peut ensuite s'en servir comme bon nous semble.

    Rappels de base:
    Un octet est égal à 8 bits (sauf dans de la très vieille informatique ou dans de rares domaines de la communication).
    Un bit est un chiffre en binaire. C'est-à-dire soit 0, soit 1.
    Pour connaître le nombre de possibilités en fonction du nombre de chiffres avec une base donnée, il suffit de faire : basechiffres.
    Si on a 32 bits on a donc 232 possibilités soit 4 294 967 296 - un joli paquet.   Types courants:   Il existe de nombreux types de variables dits "primitifs" en C++. En voici une liste non-exhaustive : bool : C'est un booléen, qui ne peut contenir que true (1) ou false (0). Il est souvent utilisé dans les conditions (voir le prochain chapitre). Attention, il ne mesure pas qu'un seul bit. int : C'est probablement le plus couramment utilisé. Sa taille dépend du type d'architecture cible : Dans le cas du x86, il fait 4 octets (et en x86-64 8 octets). C'est un nombre entier (qui peut être négatif). Il mesure au moins 16 bits. Exemple : 37 char : Il est identique au int mais ne mesure généralement qu'un seul octet - attention, cela n'est pas forcément vrai sur certaines architectures exotiques. Il est très souvent utilisé pour la manipulation de texte puisqu'il peut stocker un caractère ASCII (on peut en fait directement assigner un caractère à un char). Exemple : 'a' ou 78. Faites attention : le caractère " permet de délimiter du texte tandis que ' délimite un seul caractère. Vous ne pouvez pas assigner du texte à un char. short : Il est identique au int mais mesure au moins 16 bits, très souvent moins que int. Exemple : 298 long : C'est un int de taille supérieure ou égale au int. Il mesure au moins 32 bits. long long : C'est un int de taille supérieure ou égale au long. Il mesure au moins 64 bits. Note: Celui-ci a été introduit par C++11, veillez à utiliser un compilateur récent et à passer -std=c++11 (ou -std=c++14) au compilateur. float : C'est une valeur "flottante". Il permet de stocker des nombres à virgule. Il mesure 4 octets comme le int. Il est préférable de ne l'utiliser que lorsqu'on en a besoin car sa manipulation est plus lente. Exemple : 37.876 double : Il est identique au float mais mesure 8 octets. Exemple : 37.876   Utilisation & mots-clés:   Toutes les variables de ces types peuvent être affichés grâce à std::cout. Il suffit alors de mettre le nom de la variable à la place du "Hello World" que l'on a vu dans le tutoriel. On peut préfixer les valeurs intégrales (int, char, short) du mot-clé unsigned ce qui fait que les valeurs négatives ne seront plus acceptées. Du coup, cela nous permet d'économiser un bit si on a pas besoin de valeurs négatives (de plus, le compilateur peut mieux pousser ses optimisations). Si vous essayez d'assigner une valeur négative à votre variable unsigned, le compilateur devrait vous avertir. Le mot clé const permet de rendre une variable non modifiable, par exemple. Dans le cas des primitifs, sa valeur doit donc être assignée lors de la déclaration. Dans cet exemple simple, on place le mot clé const avant le type (voir Approfondir). #include <iostream> int main() {      float valeurFlottante = 376.84; // Attention! Le nom de cette variable n'est donné qu'à titre d'exemple. Evitez à tout prix de nommer des variables avec des noms peu explicite dans votre code (comme a, b, etc.)      unsigned int entierPositif = 73;      char lettreX = 'X'; std::cout << "La valeur flottante est : " << valeurFlottante << std::endl << "L'entier positif est : " << entierPositif << std::endl << "La lettre est : " << lettreX << std::endl; return 0; } Testez en ligne!
      Il est possible de déclarer plusieurs variables à la suite, pour alléger le code visuellement : int a = 0, b = 3, c = 4; // a, b et c sont tous des int, et on leur donne une valeur de départ int d, e, f = 4; // Attention : cela ne donne pas la valeur 4 pour d, e et f, mais seulement à f.   Portée des variables   Une variable déclarée dans un scope anonyme (rappel : délimité par des accolades) ne sera plus accessible en dehors de celle-ci. Par exemple : #include <iostream> int main() { { // On a tout à fait le droit de faire ça! int maValeur = 5; } std::cout << maValeur << std::endl; // Erreur : maValeur n'existe pas ici return 0; } clang++ prévient en effet : main.cpp:7:19: error: use of undeclared identifier 'maValeur'
    g++ nous alerte également : main.cpp:7:19: error: 'maValeur' was not declared in this scope   Si le compilateur est bien assez intelligent pour éliminer les variables inutilisées, cela peut être une bonne pratique d'utiliser des scopes anonymes quand on peut, notamment dans les grosses fonctions (il faut tout de même mieux diviser les grandes fonctions en plus petites fonctions selon le cas).   Valeur des primitifs non initialisés
    De plus, une variable que nous définissons mais que nous n'initialisons pas est indéfinie. Cela signifie que sa valeur ne sera pas garantie tant que nous lui donnons pas une valeur. De ce fait, il ne faut pas lire la valeur de cette variable si l'on ne l'a pas initialisée. Sinon, cela relève du comportement indéfini. En effet, cette variable aura des chances d'hériter de bouts de mémoire d'un ancien programme ou de bouts de mémoire que le programme a libéré. #include <iostream> int main() { int a; // La valeur de a ne sera pas forcément zéro! a = 3; // Maintenant on peut utiliser a. return 0; }   Allocation
    Quand nous définissons une variable ainsi, cela s'appelle de l'allocation automatique. Dans l'exemple précédent, a est un local à la fonction main.
    Nous verrons plus tard l'allocation dynamique moderne avec le C++11, grâce à des pointeurs intelligents qui permettent de s'abstraire de la gestion manuelle de la mémoire.
    Java utilise presque exclusivement l'allocation dynamique et abstrait la gestion manuelle de la mémoire avec un ramasse-miettes (GC). Si cela rend Java plus performant lors de l'allocation dynamique que le C++, l'allocation automatique en reste plus performante et cela permet d'éviter les coûts inévitables d'un GC.

    Nous verrons d'ici peu comment manipuler ces variables.   Approfondir (avec des concepts plus avancés) :   Taille et capacité d'un type: La fonction sizeof permet d'obtenir le nombre d'octets qu'utilise un type. Par exemple sizeof(int) retournera la taille du type int. Attention : Pour des pointeurs, par exemple sizeof(float*) mesurera la taille du pointeur plutôt que de la cible.
    Vous pouvez inclure le fichier "limits" pour pouvoir connaître de nombreuses informations sur un type donné - par exemple pour la taille maximale d'un float : std::numeric_limits<float>::max(). Documentation

    Sur coliru: int : -2147483648 to 2147483647 unsigned int : 0 to 4294967295 long : -9223372036854775808 to 9223372036854775807 unsigned long : 0 to 18446744073709551615 long long : -9223372036854775808 to 9223372036854775807 unsigned long long : 0 to 18446744073709551615 char : -128 to 127 unsigned char : 0 to 255 short : -32768 to 32767 unsigned short : 0 to 65535 float : 1.17549e-38 to 3.40282e+38 double : 2.22507e-308 to 1.79769e+308   Notez qu'il est presque toujours préféré d'utiliser un type plus petit quand on a pas besoin de plus de capacité. Cela aura pour but de réduire l'empreinte mémoire et de potentiellement légèrement accélérer le programme, mais trop se préoccuper de cela est inutile (souvenez vous, l'optimisation prématurée est la cause de tous les maux).

    Si il est nécessaire d'avoir des variables de taille fixée (les types normaux ci-dessus ont une taille définie par l'implémentation, variant ainsi entre les machines voire les compilateurs), il est mieux d'utiliser les types du header <cstdint>. Le type size_t est souvent utilisé pour désigner des tailles (ex. vector::size()). C'est un type non signé de taille définie par l'implémentation.   Const, const-correctness et const_cast en C++: Les const sont plus puissants qu'ils en ont l'air. En effet, si vous construisez un objet ou définissez une référence const, vous ne pourrez utiliser que ses méthodes définies comme const, garantissant ainsi que vous ne modifierez pas l'objet, contrairement aux final de Java. De plus, il est également possible d'avoir une version const et une version normale d'une méthode en C++. Comme dit précédemment, le mot-clé const s'applique à l'objet avant lui (ou après lui s'il se trouve au début). Par exemple : const int a = 0; int const b = 0; Les deux cas précédents sont identiques. Un exemple avec des pointeurs : int val = 0, val2 = 0; const int* a = &val; // Pointeur non-const vers un int const int const *b = &val; // Idem que a int *const c = &val; // Pointeur const vers un int non-const int const *const d = &val; // Pointeur const vers un int const const int *const e = &val; // Idem que d *a = val2; // Erreur : Assignation de valeur const a = &val2; // Correct : Assignation d'un pointeur non-const *c = val2; // Correct : Assignation de valeur non-const c = &val2; // Erreur : Assignation de pointeur const *d = val2; // Erreur : Assignation de valeur const d = &val2; // Erreur : Assignation de pointeur const On ne peut pas abandonner le const en cours de route de manière implicite: const int a = 0; int& b = a; // Erreur: Assigner un 'const int' à une référence de type 'int' élimine le 'const' Cependant, si on a un objet de départ non-const et une référence vers celui-ci qui est const, il est possible d'utiliser const_cast pour obtenir une référence non-const à partir de cette référence const. Attention au comportement indéfini, il ne faut surtout pas faire ça si l'objet de départ est const! int a = 0; const int& ref = a; int& b = const_cast<int&>(ref); // Correct const int a = 0; const int& ref = a; int& b = const_cast<int&>(ref); // ATTENTION: Comportement indéfini!   Comportements spéciaux:
    Quand on dépasse la capacité maximale d'une variable, il se passe ce qu'on appelle un overflow.
    Le standard du C++ ne définit pas le comportement d'un overflow sur des types signés (c'est-à-dire qui peuvent avoir une valeur positive ou négative, comme int, char, short). Il ne faut donc pas baser le fonctionnement de son programme sur de tels overflow, car on ne sait pas ce qui va se passer, et en général les optimiseurs et leurs compilateurs se basent sur le principe que le code de l'utilisateur ne se base pas sur du comportement indéfini. Cela peut paraître agaçant, mais c'est une des puissances (ou faiblesses) du C++ : Cela permet de laisser place à de puissantes optimisations au niveau de compilateur.
    Avec les variables unsigned, c'est différent : En cas d'overflow, la variable revient à 0, cette fois-ci le standard le définit bien!   Notez qu'il existe des cas comme ceux-ci : Utiliser l'opérateur binaire << sur un entier négatif cause un comportement indéfini, utiliser l'opérateur binaire >> sur un entier négatif cause un comportement défini par l'implémentation.
    Pour les types flottants, l'overflow provoque un comportement indéfini surtout car le fonctionnement des float est plus compliqué (et serait inutilement complexe à implémenter de manière standardisée pour diverses raisons).
    • 4 commentaires
    • 1030 vues
  • SystemGlitch

    Prologue

    Par SystemGlitch

    Bonjour chers/chères Bukkitiens/Bukkitiennes !   Bienvenue dans le cours de développement Java! Que pensez-vous de commencer par l'introduction?           Java, non, on ne parle pas de la danse ridicule des années 1920!   Le Java est un langage de programmation apparu en 1995, et oui! 1995! Mais il était alors bien différent de celui que nous connaissons aujourd'hui! Il fut développé par l'entreprise Sun MicroSystems qui fut rachetée par Oracle Corporation en 2009. Il n'y pas si longtemps que ça finalement!   Java est un langage orienté objet robuste, puissant et surtout, très portable car il est multi-plateforme. Sa grande portabilité réside dans un concept utilisé auparavant par le Pascal, il utilise une machine virtuelle que l'on nomme Java Runtime Environment (JRE), qui va faire l'intermédiaire entre le bytecode (écrit par le compilateur grâce au code de l'utilisateur), et va le transformer en langage compréhensible par la machine concernée. Il y a un autre aspect de sa "portabilité", se fût à sa création, sa syntaxe ressemble beaucoup à celle du C++ et ce n'est pas une coïncidence, les ingénieurs de l'époque travaillaient essentiellement en C, reprendre cette syntaxe permettait à une large communauté de pouvoir utiliser leur langage très rapidement, et c'est en grande partie grâce à cela que le Java est devenu vite populaire. Sa puissante API permet de gérer un grand nombre de domaines comme les interfaces graphiques, la gestion des fichiers, que ce soit en local ou sur une base de données, et bien plus encore!   Ses possibilités sont très diversifiées. Les bases sont faciles à intégrer mais maîtriser les différents domaines demande plusieurs années de pratique... Mais ne vous inquiétez pas, nous irons pas-à-pas.   Contrairement à d'autres cours sur Internet, nous ne nous contenterons pas de dresser une liste exhaustive des possibilités du Java et de Bukkit car ce serait trop long et inutile! Nous ne somme pas là pour faire du bourrage de crane! Nous voulons vous fournir les outils nécessaires pour que vous sachiez vous débrouiller tout seul, sans être un assisté qui se contente de recopier un tutoriel! Et plus important encore, vous comprendrez cette superbe vidéo!               Ne plongez pas la tête la première!   Afin de développer avec ce merveilleux langage, il vous faut d'abord installer Java, mais pas une simple JRE, la version Java SE Development Kit (JDK). Nous tenons aussi à signaler que rien ne vous empêche d'installer plusieurs JDK et de choisir celle que vous voulez pour votre projet, via votre IDE.   Il est évidemment possible de développer à l'aide d'un simple éditeur de texte, mais avouez que l'idée même en est repoussante! Pour développer, il vous faudra des couleurs, de l'ordre et un environnement agréable, afin de mieux s'y retrouver au sein de son code. On appelle ces logiciels IDE (Integrated development environment). Nous allons explorer le monde du Java avec un IDE répondant au nom d'Eclipse. Vous pouvez télécharger la version dont nous aurons besoin ici!   Vous voila prêt à commencer me direz-vous! Et bien désolé de vous décevoir, mais non, il y a encore des choses à savoir avant de débuter. Vous vous doutez que ce genre d'outil n'est pas ce qu'il y a de plus simple à utiliser.   Je pense que vous n'aurez pas trop de difficultés à apprendre les différents raccourcis clavier, ceux-ci sont spécifiés dans les menus. Ceux-ci sont les plus importants: Ctrl + Shift + O : Il vous permet de rapidement générer les imports dont vous aurez besoin pour faire fonctionner votre code. Ctrl + S : Il permet de sauvegarder la classe sur laquelle vous travaillez actuellement. Ctrl + Shift + S : Il permet de tout sauvegarder. Toutes les classes modifiées depuis la dernière sauvegarde seront sauvegardées !   Jetez un œil à cette rapide visite guidée de votre IDE :       Vous pourrez trouver plus d'informations à propos de votre IDE en consultant la documentation officielle d'Eclipse. Nous apprendrons tout de même quelques unes de ses fonctionnalités ensemble!   Lancez Eclipse. Une boite de dialogue apparaîtra. Spécifiez le dossier dans lequel vous voulez que tous vos projets soient sauvegardés. On appelle ce dossier "Workspace".   Faites un clic droit dans l'explorateur de packages et créez un nouveau projet :     Une boite de dialogue s'ouvrira pour vous demander de définir les paramètres de votre projet. Assurez-vous que ces derniers soient bien les mêmes que sur l'image suivante :     Cliquez sur "Finish". Votre projet est créé! Nous le remplirons plus tard! Maintenant, passons aux choses sérieuses!     JeremGamer et JackBlue  
    • 9 commentaires
    • 2341 vues
  • CitronVert

    Recrutement été 2016 - Résultats de la deuxième vague

    Par CitronVert

    Bonjour à toutes et à tous,   Comme vous le savez, nous avons lancé une nouvelle campagne de recrutement début août. Nous avons récolté vos candidatures et nous avons voté pour ou contre chaque personne qui s'était présentée. Pour cette deuxième vague, nous avons reçu plusieurs candidatures modérateurs, nous les avons refusées car nous étions en surplus de modérateur, ne prenez pas ça comme un refus personnel ;).   Petites informations   Les membres ayant été acceptés sont en période de test. Concernant ceux qui n'ont pas été retenus, votre 'refus' n'est pas un refus définitif. Les raisons pourront vous être communiqués en MP, sur demande. La prochaine vague de recrutements aura lieu l'année prochaine   Changements dans le staff   Horld3n, recruté en tant que Community Manager   L'équipe compte donc aujourd'hui un Community Manager, seize modérateurs, trois administrateurs et deux fondateurs   L'équipe Bukkit France aujourd'hui   Fondateurs : abclive, iooner Administrateurs : Eldra, Mentalow, Pskyco Modérateurs : Alishk, Azerkiller, Chk, Chipie, CitronVert, como89, Crumble14, Dartasen, Dragorn421, Jackblue, JeremGamer, Jimi, Mac', Manercraft, Tanki, Technowix. Community Manager : Horld3n Bien à vous, le staff Bukkit France.
    • 0 commentaire
    • 770 vues

Nos blogs communautaires

  1. Bonjour à toutes et tous,

     

    Lors du passage à la dernière version d'IPBoard il y a quelques mois, il y a eu un problème avec les balises codes et le format en général dans les blogs. Parmi ces problèmes, on peut retrouver la perte de police, ou les retours à la ligne dans les balises code. Cela rendait les cours parfaitement illisibles.

     

    J'ai récemment reformaté l'intégralité des cours, des TPs et des Hors-série pour qu'ils soient de nouveau lisibles ! :) Cela a pris beaucoup de temps mais je pense que cela en vaut la peine.

     

    Si vous n'avez pas encore commencé votre aventure dans le monde de Java, c'est le moment !

     

    Votre prof de Java préféré,

    JeremGamer

  2. Bonjour à toutes et à tous,

     

    Comme vous le savez, nous avons lancé une nouvelle campagne de recrutement début août. Nous avons récolté vos candidatures et nous avons voté pour ou contre chaque personne qui s'était présentée. Pour cette deuxième vague, nous avons reçu plusieurs candidatures modérateurs, nous les avons refusées car nous étions en surplus de modérateur, ne prenez pas ça comme un refus personnel ;).

     

    Petites informations

     

    • Les membres ayant été acceptés sont en période de test.
    • Concernant ceux qui n'ont pas été retenus, votre 'refus' n'est pas un refus définitif. Les raisons pourront vous être communiqués en MP, sur demande.
    • La prochaine vague de recrutements aura lieu l'année prochaine

     

    Changements dans le staff

     

    Horld3n, recruté en tant que Community Manager

     

    L'équipe compte donc aujourd'hui un Community Manager, seize modérateurs, trois administrateurs et deux fondateurs

     

    L'équipe Bukkit France aujourd'hui

     

    Fondateurs : abclive, iooner

    Administrateurs : Eldra, Mentalow, Pskyco

    Modérateurs : Alishk, Azerkiller, Chk, Chipie, CitronVert, como89, Crumble14, Dartasen, Dragorn421, Jackblue, JeremGamer, Jimi, Mac', Manercraft, Tanki, Technowix.

    Community Manager : Horld3n

    Bien à vous,

    le staff Bukkit France.

  3. BUKKIT FRANCE SUNDAY SUM n°24

     


    L'Edito :
    Bonjour à tous,
    Le 3 septembre 2013, nous avions dépassé les 100.000 messages, en juin dernier les 150.000 et aujourd'hui nous sommes arrivés au cap des 200.000. C'est énorme, merci à vous d'avoir contribué que ce soit de près ou de loin à atteindre ce palier !

    OcIyKo2.png


    Concernant les BSS, le changement de format s'est enfin terminé et ils seront publiés le premier Dimanche de chaque mois.
    Au programme cette semaine une grande part d'actualités sur la 1.9, un gros projet, un plugin inédit et une map qui reconnstitue le château de Neuschwanstein.

     


    Actualités :
    Nous commençons ce récapitulatif à Londres, où se déroule en ce moment même la quatrième édition de la Minecon 2015. Ce midi a été lancé un album disponible sur imgur qui regroupe toutes les nouveautés de Minecraft 1.9. Je vais commencer par les ajouts concernant le PvP :

    • Tout d'abord les boucliers dont les mécaniques n'ont pas encore été déterminées. On sait uniquement qu'ils fonctionneront comme les bannières pour le système de customisation. Mojang nous propose un petit screenshot :

    YWYnLYz.png

    • Mojang avait précédemment annoncé de nouvelles flèches, ils nous expliquent aujourd'hui en détail à quoi elles vont servir. La flèche spectrale va permettre de voir la cible touchée à travers les murs, la flèche de poison empoisonnera la cible et la flèche d'invisibilité la rendra invisible.
    • Par ailleurs un changement graphique a eu lieu au niveau des potions, les effets seront situés sur deux lignes en haut à droite de l’écran et non plus dans l'inventaire du joueur. La première ligne sera consacrée aux bonus et la seconde aux malus.


    Toutefois, les ajouts concernant le PvP ne sont pas les seuls, les développeurs de Mojang ont travaillé sur un nouveau mob et une nouvelle plante de l'Ender.

    • La nouvelle plante sera semblable à un cactus et se nomme Chorus Tree, lorsqu'ou le casse, il droppe des Chorus Fruits qui sont mangeables.
    • Le nouveau mob, quant à lui porte le nom de Shulka. Il s'ouvre et se ferme comme une coquille, son attaque est très impressionnante car c'est un missile qui suit le joueur. Ce mob donne un effet de lévitation qui est considéré comme un malus :

    W8CEb3J.jpg


     

    Le troisième ajout important de la 1.9 est la refonte de l'End :

    • Il comporte désormais un donjon avec de nouveaux blocs (voir image ci-dessus). Le donjon est nommé "End city Dungeon" et ressemble de l'extérieur à ceci :


    fOYhP8a.png

    • Des "portes" pourront vous téléporter entre les différentes îles de l'End, il suffit de jeter une Ender Pearl dedans :


    bIdxXZq.png

     


    Et enfin, dernier gros ajout de la 1.9 : la deuxième main. Si son existence est connue depuis plus d'un mois, je n'avais pas fait de point dessus. Elle va sûrement déstabiliser les joueurs à sa sortie car son utilisation est un peu complexe. Un nouveau slot à été ajouté à l'inventaire pour la deuxième main pour pouvoir l'utiliser. Elle permet par exemple de ternir une enderpearl ou une torche et il faudra faire un clic droit pour l'utiliser. Petit exemple : si vous êtes en train de miner avec la pioche dans la main droite, vous n'aurez qu'à faire un clic droit pour poser une torche. Lors d'un combat à l'arc, la flèche prioritaire sera celle placée dans votre main.

     

    Pour finir avec les annonces concernant Minecraft, une version spéciale Windows 10 gratuite pour ceux qui ont un compte Minecraft Premium sera disponible le 29 Juillet. Elle permettra de jouer avec les joueurs de Minecraft PE car elle tournera sur la même version que sur PE. Voilà, c'est tout pour les actualités de ces dernières semaines, je vous invite à suivre la Minecon en direct ici.

     

    Projet du mois :

     

    Le projet du mois est Rubidia, mené par pmilon. Ce projet de serveur RPG-PvP est très ambitieux car il souhaite améliorer le jeu et non le modifier comme différents types de serveurs MMORPG actuels. Ils ont déjà ajouté des niveaux, des classes, des compétences, un système d'échange ou encore un système de musiques. Ils ne s'arrêtent tout de même pas là car ils souhaitent rajouter un grand nombre de quêtes ou des donjons. L'équipe à déjà créé Mearwood, une des cinq villes qui composeront le serveur, en voici quelques screens :


    91098120150619162947.png
    26179320150619162232.png
    68545420150619162847.png

     

    Ce projet très ambitieux ne compte que 3 membres d'équipe et semble être très prometteur vu le travail acharné de ses membres. Je vous invite à aller voir le sujet pour plus de précisions au niveau de ce projet :

     


    Plugin du mois :
    Le plugin que je vais vous proposer aujourd'hui est unique en son genre. On connaissait les particules de Redstone lorsque l'on touchait un joueur mais MrSheepSheep est allé plus loin en permettant de rajouter un effet de sang sur l'écran du joueur quand il prend un coup. Voici tout le plugin résumé dans ce gif :

    9wfWY23.gif?1*

     


    C'est une très bonne idée qu'à eu l'auteur de faire cela car c'est très réaliste. Le plugin propose un modificateur d'intensité, un mode dégradé pour rendre plus fluide la disparition de l'effet à l'écran ou encore une texture qui rend l'effet plus réaliste. C'est un plugin inédit que nous a concocté MrSheepSheep. Bravo à lui !

     


    Map du mois :

     

    La map du mois est une reconstitution très réussie du chateau de Neuschwanstein en Bavière. L'auteur français de ce build est ParkVador qui nous donne avec le château un terraforming plus que réussi. Cette reconstitution est tellement bien ficelée que l'on ne trouve pas de différences avec le château réel.
    Ce fort est situé sur une colline au bord d'un lac au centre d'une vallée enneigée éblouissante. Bien sûr les arbres customs ne manquent pas pour rendre cette map encore plus éclatante. Je vous laisse voir quelques images de cette petite merveille avec les rendus de l'auteur :

     


    miniature28718603.jpg
    castleneuschwansteinbyparkvador-238714793.jpg
    castleneuschwansteinbyparkvador-258691499.jpg
    1024px-Neuschwanstein_castle.jpg
    castleneuschwansteinbyparkvador-558691439.jpg


  4. Une condition peut être soit vraie, soit fausse.
    Par exemple, la condition 2 < 3 est vraie, mais la condition 5 < 2 sera fausse.

    Attention : Pour vérifier si un nombre est égal à un autre, on utilise == et non pas =, qui est l'opérateur d'assignation (pour assigner une valeur à une variable) et non pas celui de comparaison.

    Il existe la structure conditionnelle if en C++. Elle permet de vérifier une condition (= tester) et si elle est vraie, alors du code sera exécuté. Il est possible de la compléter avec else, qui exécute du code dans le cas où la condition est fausse, ou else if, qui permet de vérifier une autre condition dans le cas où la première est fausse.
    Pour délimiter le code à exécuter si la condition est vraie, on utilise soit des accolades, soit rien si on veut n'exécuter qu'une seule instruction (cela ne compte pas autres conditions et boucles).

    #include <iostream>
    
    int main()
    {
        int valeur = 2;
      
        if (valeur < 7)
        {
            std::cout << valeur << " est bel et bien inférieur à 7!" << std::endl;
        }
        else if (valeur == 7)
        {
            std::cout << "La valeur est égale à 7" << std::endl;
        }
        else
        {
            std::cout << valeur << " est inférieur à 7." << std::endl;
        }
      
        return 0;
    }
    #include <iostream>
    
    int main()
    {
        int valeur = 2;
      
        if (valeur < 7)
            std::cout << valeur << " est bel et bien inférieur à 7!" << std::endl;
        else if (valeur == 7)
            std::cout << "La valeur est égale à 7" << std::endl;
        else
            std::cout << valeur << " est inférieur à 7." << std::endl;
      
        return 0;
    }

    Attention, deux erreurs très courantes chez les débutants (et pas que) :

    • On ne rajoute jamais de point-virgule après une structure conditionnelle (et plus tard, pareil avec les boucles)!
    #include <iostream>
    
    int main()
    {
        int valeur = 2;
      
        if (valeur > 7); // Surtout pas ça! Cela équivaut au code ci-dessous...
            std::cout << valeur << " est supérieur à 7!" << std::endl;
    
      
        return 0;
    }
    #include <iostream>
    
    int main()
    {
        int valeur = 2;
      
        if (valeur > 7)
        {
            // Mettre un point-virgule après une condition, ça équivaut à dire : si quelque chose, alors ne rien faire.
            // Ce n'est pas du tout ce qu'on veut! Le pire dans tout ça, c'est que le code en dessous va être toujours exécuté.
            // En effet, rien n'empêche de mettre du code dans une scope "sauvage".
        }
    
        {
            std::cout << valeur << " est supérieur à 7!" << std::endl;
        }
    
      
        return 0;
    }
    • Quand on ne met pas de scope, on ne peut pas mettre deux instructions à la suite!
    #include <iostream>
    
    int main()
    {
        int valeur = 2;
      
        if (valeur > 7)
            std::cout << valeur << " est supérieur à 7!" << std::endl; // Cela ne va être exécuté que lorsque la valeur est supérieure à 7...
            std::cout << "Cette valeur est vraiment supérieure à 7!" << std::endl; // Ce code va être exécuté peut importe quelle est la condition! Une faille majeure dans OSX était justement due à ce genre d'erreur. Faites attention!
      
        return 0;
    }

    Approfondir :

    Si on utilise un quelconque nombre en tant que condition, la condition sera fausse si nombre == 0 et vraie sinon.
    Pour vérifier si un tel nombre est non nul (non égal à zéro), nous avons complètement le droit de faire if (nombre) et c'est couramment fait. Par soucis de clarté, j'évite de faire if (!nombre) pour vérifie si le nombre est nul. Sachez que cela ne cause aucun problème cependant, mais je préfère garder mon code explicite au possible.

     

    Les opérateurs logiques nous permettent de vérifier plusieurs conditions à la fois dans une seule boucle if.

    En voici la liste :

    • || signifie OU. Par exemple, if (valeur < 3 || valeur > 8) permet de vérifier si la valeur est inférieure à 3 OU supérieure à 8.
    • && signifie ET. Par exemple, if (valeur1 == 7 && valeur2 == 3) permet de vérifier si valeur1 est égale à 7 ET si valeur2 est égale à 3.
    • ! signifie NON. Cet opérateur permet d'inverser la valeur d'un booléen (ou de rendre un nombre non égal à 0 égal à 0 (pas zéro => 0) ou un nombre égal à zéro égal à 1 (0 => 1).
      Le C++ ne fournit pas d'opérateur OU EXCLUSIF logique (qui serait ^^) mais !a != !b permet d'obtenir le même résultat, c'est-à-dire que la condition sera vraie seulement si a est vrai mais pas b.
      Vous pouvez englober cela dans une simple fonction :
      inline bool xor(const bool& a, const bool& b)
      {
      	return (!a) != (!b);
      }

      Au passage : inline informe au compilateur qu'on souhaite que la fonction soit directement intégrée au code. C'est bien pour du petit code ou du code exécuté peu de fois pour gagner en performances en éradiquant le temps perdu par l'exécution de la fonction, mais peut ralentir et grandement alourdir le code binaire résultant pour de larges fonctions ou des fonctions appelées à divers endroits du code. Ce n'est pas une garantie et cela n'arrive en général que lorsqu'on active les optimisations (-O3 par exemple).
      const bool& passe les deux variables par référence constante pour permettre au compilateur de pousser ses optimisations (ici ça ne servirait que si l'inline n'est pas possible).


    On peut englober une condition de parenthèses pour obtenir une meilleure clarté du code ou pour palier la priorité des opérateurs, par exemple : if ((valeur1 < 3) && ((8 + valeur2) > 7)).