Recherche de plugin (ou de système) pour évènement commun en combat.

J'utilise le logiciel Netbeans qui est un éditeur de code très puissant permettant de nombreuse chose et surtout gratuitement (http://rpgmakervx.1fr1.net/t19795-installer-et-utiliser-netbeans-avec-un-projet-rmmv). De plus, je connais très très bien l'architecture du code de rpgmaker, je m'y retrouve du coup facilement.

Et puis développeur logiciel, c'est mon métier! ^_^

Mon mari m'avais mise sous Eclipse, mais du coup il me dit que Netbeans est très bien aussi, donc je vais essayer de m'y mettre un peu. Mais gentiment, parce que c'est vraiment du chinois pour moi tout ça...

J'ai été pas mal occupé dans ma journée, j'ai donc passé environ 2h en tout et pour tout sur ce plugin, analyse et développement compris :

Il faut donc créer un fichier Tonyryu_SkillReplaceAtt.js dans le dossier plugin du projet et y mettre ce code :

Code:

//=============================================================================
// Tonyryu_SkillReplaceAtt.js
//=============================================================================

/*:
 * @plugindesc Plugin permettant de remplacer l'attaque par défaut par une compétence
 * @author Tonyryu
 * @version 1.0.1
 *
 *
 * @help http://www.tonyryudev.com/
 *
 */

/*
 * Suivi de version
 * 1.0.0 : 23/04/2016 : Tonyryu : Création plugin
 * 1.0.1 : 23/04/2016 : Tonyryu : Modification pour forcer la préparation d'attaque
 *
 */

var Imported = Imported || {};
Imported.Tonyryu_SkillReplaceAtt = true;

var Tonyryu = Tonyryu || {};
Tonyryu.SPA = Tonyryu.SPA || {};

(function() { // Définition de la fonction anonyme qui sera exécuté immédiatement, permet ainsi d'éviter d'ajouter des variables globales inutiles

  /**********************************************************************
  *----------------------------------------------------------------------
  * Modification du "classe" Game_Actor
  *----------------------------------------------------------------------
  **********************************************************************/
  /**********************************************************************
  * Méthode : initialize (surcharge)
  * Fonction : permet d'ajouter un flag d'activation d'attaque
  * Params : --
  **********************************************************************/
  var _Game_Actor_initialize = Game_Actor.prototype.initialize;
  Game_Actor.prototype.initialize = function(actorId) {
    _Game_Actor_initialize.call(this, actorId);
    this._skillAtt = false;
  };
  
  /**********************************************************************
  * Méthode : activateSkillAtt (ajout)
  * Fonction : permet d'activer le flag d'attaque
  * Params : --
  **********************************************************************/
  Game_Actor.prototype.activateSkillAtt = function() {
    this._skillAtt = true;
  };
  
  /**********************************************************************
  * Méthode : performAction (surcharge)
  * Fonction : permet de basculer sur une préparation d'attaque normal
  * Params : --
  **********************************************************************/
  var _Game_Actor_performAction = Game_Actor.prototype.performAction;
  Game_Actor.prototype.performAction = function(action) {
    _Game_Actor_performAction.call(this, action);
    if(this._skillAtt)
      this.performAttack();
    this._skillAtt = false;
  };

  /**********************************************************************
  *----------------------------------------------------------------------
  * Modification du "classe" Window_ActorCommand
  *----------------------------------------------------------------------
  **********************************************************************/
  /**********************************************************************
  * Méthode : addAttackCommand (surcharge)
  * Fonction : permet de faire une recherche des skills de remplacement
  *            et d'ajouter la commande du skill à la place de l'attaque
  * Params : --
  **********************************************************************/
  var _Window_ActorCommand_addAttackCommand = Window_ActorCommand.prototype.addAttackCommand;
  Window_ActorCommand.prototype.addAttackCommand = function() {
    this._skillAtt = null;
    var tabSkills = this._actor.skills();
    for(var i= 0; i < tabSkills.length; i++){
      var skill = tabSkills[i];
      if(skill.meta['remplAtt'] && this._actor.isSkillWtypeOk(skill))
        this._skillAtt = skill;
    }
    if(!this._skillAtt)
      _Window_ActorCommand_addAttackCommand.call(this);
    else
      this.addCommand(this._skillAtt.name, 'attSkill', this._actor.canUse(this._skillAtt));
  };
  
  /**********************************************************************
  * Méthode : attSkill (ajout)
  * Fonction : permet retourner la compétence de remplacement
  * Params : --
  **********************************************************************/
  Window_ActorCommand.prototype.attSkill = function() {
    return this._skillAtt;
  };

  /**********************************************************************
  *----------------------------------------------------------------------
  * Modification du "classe" Window_SkillList
  *----------------------------------------------------------------------
  **********************************************************************/
  /**********************************************************************
  * Méthode : includes (surcharge)
  * Fonction : permet de modifier la condition d'incusion de la compétence
  *            dans la liste
  * Params : --
  **********************************************************************/
  var _Window_SkillList_includes = Window_SkillList.prototype.includes;
  Window_SkillList.prototype.includes = function(item) {
    var result = _Window_SkillList_includes.call(this, item);
    if($gameParty.inBattle())
      return result && !item.meta['remplAtt'];
    else
      return result;
  };

  /**********************************************************************
  *----------------------------------------------------------------------
  * Modification du "classe" Scene_Battle
  *----------------------------------------------------------------------
  **********************************************************************/
  /**********************************************************************
  * Méthode : onAttSkill (ajout)
  * Fonction : permet de gérer la sélection de la compétence de remplacement
  * Params : --
  **********************************************************************/
  Scene_Battle.prototype.onAttSkill = function() {
    var skill = this._actorCommandWindow.attSkill();
    var action = BattleManager.inputtingAction();
    action.setSkill(skill.id);
    BattleManager.actor().setLastBattleSkill(skill);
    BattleManager.actor().activateSkillAtt();
    this.onSelectAction();
  };
  
  /**********************************************************************
  * Méthode : createActorCommandWindow (surcharge)
  * Fonction : permet d'ajouter le lien entre la commande attSkil et la
  *            fonction onAttSkill
  * Params : --
  **********************************************************************/
  var _Window_ActorCommand_createActorCommandWindow = Scene_Battle.prototype.createActorCommandWindow;
  Scene_Battle.prototype.createActorCommandWindow = function() {
    _Window_ActorCommand_createActorCommandWindow.call(this);
    this._actorCommandWindow.setHandler('attSkill', this.onAttSkill.bind(this));
  };

})();


Pour donner la propriété de remplacement à une compétence, il faut ajouter le tag dans le champs remarque.

oh merci beaucoup. Je mets ça en place maintenant mais je ne pense tester que demain (vu l'heure, comme qui dirait.... incongrue....). Dès que c'est fait, je te dis et je te fais un retour (pas pro hein ...) sur mon utilisation. Merci encore !

Edit: Excuse ma noobitude, mais c'est quoi le tag que je dois écrire dans la fenêtre remarque ? j'ai essayé: attSkill , remplAtt et aussi SkillReplaceAtt mais ça n'a pas marché.

A zut, le tag n'est pas passé dans le post précédent car il a été considéré comme du code html :

Code:

<remplAtt>

Il faut passer les tag entre < et >, car il sont automatiquement interprété lors du chargement des fichiers et sont transféreq dans la propriété meta de l'instance chargée.
Mes scripts précédents sont en cours de modification pour prendre en compte cette spécificité.

Je te propose, maintenant, de te faire un plugin, permettant de gérer d'autre type de ressource pour l'utilisation d'une compétence. qui est actuellement limité à Hp, MP, TP. Et pourquoi pas en ajouter d'autre comme la valeur d'une variable, ce qui te permettra de passer outre l'événement commun, et de rendre inactif la compétence si plus de munition.

ça marche ! Génial !
Au final je n'ai pas vesoin de t'embêter davantage. Maintenant si tu as envie d'approfondir les choses et de perfectionner tout ça, pourquoi pas. Du coup, je te présente ce que j'ai fait en évent (ce qui permettra à d'autres de faire la même chose si ils le souhaite, puisque le plugin est juste au dessus:

L'idée:
Il s'agit d'une arme nommée Pistolet à recharge.
Cette arme, en fonction des balles qu'elle continent change de caractéristique: avec des balles de sommeil elle devient Pistolet à recharge de sommeil, avec des balles empoisonnées, un pistolet à recharge empoisonnant etc....
Chaque type de balles spéciales peut être fabriqué par l'alchimiste.
Lorsque l'arme a des balles spéciales on décompte les balles, lorsqu'elles sont épuisées, on repasse sur des balles normales qui elles ne sont pas décomptées.
Voilà je crois que j'ai fait le tour...

Voici le système:
1-Le joueur équipe sont personnage d'un pistolet à recharges.

Spoiler:

Ce pistolet n'a rien d'extraordinaire... (recopiez pas les stats aveuglément, je ne les ai pas testées en jeu encore....) Il fonctionne normalement, y a rien à signaler.

2-le joueur achète ou craft des balles de sommeil

Spoiler:

3-Il utilise les balles de sommeil ce qui déclenche un évènement commun que j'ai nommé "pistolet" (oui il y a deux fois la même chose d'écrite mais en fait c'est simplement parce que mon joueur peut choisir entre deux héros au début de la partie, ils ont le même nom modifié ensuite par le joueur, mais pas le même ID)

Spoiler:

Du coup l'équipement du héros change, au lieu d'être équipé d'un pistolet à recharges, il est maintenant équipé d'un pistolet à recharges de sommeil contenant 20 balles.

4-Grâce à Tonyryu, le héros a une compétence Tir qui est venu remplacer la compétence Attaque dès le niveau 1 (mon héros n'utilise que le pistolet)

Spoiler:

5-A chaque fois que le joueur utilise la compétence Tir, cela appelle un évènement commun que j'ai nommé "Munition" qui a 2 fonctions:
- compter les balles.
- modifier le pistolet si il n'y a plus de balle. Ainsi si le nombre de balles arrive à 0 le joueur reçoit un message lui indiquant qu'il repasse sur des munitions de type normal. Son "pistolet à recharges de sommeil" redevient un simple "pistolet à recharges".

Spoiler:

Donc en fait ça ne m'intéresse pas forcément de rendre la compétence inactive. Par contre quelque chose qui permette d'afficher une jauge ou les balles restantes ça serait pas mal.

Voilou tu sais tout !

Ce qui pourrait le faire, c'est un pluggin permettant un nombre d'utilisation d'un équipement et de le retirer une fois que le compteur est épuisé, avec une info au niveau de l'écriture de la première compétence, ça sera spécifique pour toi également. Mais ce ne sera pas très long a faire.

Aujourd'hui, je m'occupe de mon potager, je te ferais ça ce soir.

ça revient à un plugin d'usure au final sauf que l'objet ne disparait pas il est simplement retiré.

je vais faire simple, je vais juste ajouter une notion de munition au niveau des personnages et qui sera affiché à l'endroit de la compétence d'attaque.

ça me semble mieux, parce que si l'arme du joueur est déséquipée en plein combat et non remplacée, ça risque de poser comme qui dirait... un petit soucis...

est-ce que ce visuel correspond à ce que tu veux ?

Ah oui ! c'est super ! C'est exactement ce que je voulais !

Voici le nouveau plugin d'affichage des munitions (Tonyryu_SimpleAmmo.js) :

Code:

//=============================================================================
// Tonyryu_SimpleAmmo.js
//=============================================================================

/*:
 * @plugindesc Plugin permettant d'ajouter une gestion de munition simple
 * @author Tonyryu
 * @version 1.0.0
 *
 * @param Ammo name
 * @desc Nom court qui sera placé devant le nombre de munition
 * @default Muni.
 *
 * @param ID Ammo Weapon Type
 * @desc ID des types d'arme nécessitant des munitions, séparé par ,
 * @default 9
 *
 * @help http://www.tonyryudev.com/
 *
 */

/*
 * Suivi de version
 * 1.0.0 : 24/04/2016 : Tonyryu : Création plugin
 *
 */

var Imported = Imported || {};
Imported.Tonyryu_SimpleAmmo = true;

var Tonyryu = Tonyryu || {};
Tonyryu.SA = Tonyryu.SA || {};

(function() { // Définition de la fonction anonyme qui sera exécuté immédiatement, permet ainsi d'éviter d'ajouter des variables globales inutiles

  var parameters = PluginManager.parameters('Tonyryu_SimpleAmmo');
  var param_ammoName = String(parameters['Ammo name'] || 'Mun.');
  var param_ammoWeaponType = String(parameters['ID Ammo Weapon Type'] || '9');

  /**********************************************************************
  *----------------------------------------------------------------------
  * Modification de la "classe" Game_Actor
  *----------------------------------------------------------------------
  **********************************************************************/
  /**********************************************************************
  * Méthode : initialize (surcharge)
  * Fonction : permet d'ajouter des variables de gestion de munition
  * Params : --
  **********************************************************************/
  var _Game_Actor_initialize = Game_Actor.prototype.initialize;
  Game_Actor.prototype.initialize = function(actorId) {
    _Game_Actor_initialize.call(this, actorId);
    this._ammo = -1;
  };
  
  /**********************************************************************
  * Méthode : setAmmo (ajout)
  * Fonction : permet de définir le nombre de munition (-1 : infini)
  * Params : pNbAmmo : Nombre de munition
  **********************************************************************/
  Game_Actor.prototype.setAmmo = function(pNbAmmo) {
    this._ammo = pNbAmmo;
  };
  
  /**********************************************************************
  * Méthode : getAmmo (ajout)
  * Fonction : permet de récupérer le nombre de munition
  * Params : --
  **********************************************************************/
  Game_Actor.prototype.getAmmo = function() {
    return this._ammo;
  };
  
  /**********************************************************************
  * Méthode : addAmmo (ajout)
  * Fonction : permet d'ajouter un nombre de munition
  * Params : pNbAmmo : Nombre de munition
  **********************************************************************/
  Game_Actor.prototype.addAmmo = function(pNbAmmo) {
    this._ammo += (pNbAmmo || 0);
  };
  
  /**********************************************************************
  * Méthode : isWtypeAmmoEquipped (ajout)
  * Fonction : permet de vérifier si le perso est équipé d'une arme a munition
  * Params : --
  **********************************************************************/
  Game_Actor.prototype.isWtypeAmmoEquipped = function() {
    if(param_ammoWeaponType){
      param_ammoWeaponType = param_ammoWeaponType.replace(' ', '');
      var tabIdWeaponType = param_ammoWeaponType.split(',');
      for(var i= 0; i < tabIdWeaponType.length; i++){
        if(this.isWtypeEquipped(Number(tabIdWeaponType[i])))
          return true;
      }
    }
    return false;
  };
  

  /**********************************************************************
  *----------------------------------------------------------------------
  * Ajout de la "classe" Window_Ammo
  *----------------------------------------------------------------------
  **********************************************************************/
  function Window_Ammo() {
    this.initialize.apply(this, arguments);
  }

  Window_Ammo.prototype = Object.create(Window_Base.prototype);
  Window_Ammo.prototype.constructor = Window_Ammo;

  /**********************************************************************
  * Méthode : initialize
  * Fonction : initialisation de la fenêtre
  * Params : --
  **********************************************************************/
 Window_Ammo.prototype.initialize = function() {
    var width = Window_ActorCommand.prototype.windowWidth();
    var height = this.fittingHeight(1);
    Window_Base.prototype.initialize.call(this, 0, 0, width, height);
    this._actor = null;
    this.openness = 0;
  };
  
  /**********************************************************************
  * Méthode : standardPadding
  * Fonction : défini un padding standard plus petit que la normal
  * Params : --
  **********************************************************************/
  Window_Ammo.prototype.standardPadding = function() {
    return 9;
  };

  /**********************************************************************
  * Méthode : setActor
  * Fonction : permet de changer de personnage pour la gestion d'affichage
  * Params : --
  **********************************************************************/
  Window_Ammo.prototype.setActor = function(actor) {
    this._actor = actor;
    this.refresh();
    if(this._actor.isWtypeAmmoEquipped())
      this.open();
    else
      this.close();
  };

  /**********************************************************************
  * Méthode : refresh
  * Fonction : défini le contenu de l'affichage
  * Params : --
  **********************************************************************/
  Window_Ammo.prototype.refresh = function() {
    var nbAmmo = this._actor.getAmmo();
    if(nbAmmo === -1)
      this.drawTextEx(param_ammoName + ' : ∞', this.textPadding(), 0);
    else
      this.drawTextEx(param_ammoName + ' : ' + String(nbAmmo), this.textPadding(), 0);
  };


  /**********************************************************************
  *----------------------------------------------------------------------
  * Modification du "classe" Scene_Battle
  *----------------------------------------------------------------------
  **********************************************************************/
  /**********************************************************************
  * Méthode : createAmmoWindow (ajout)
  * Fonction : Ajoute la fenêtre de munition dans la scene
  * Params : --
  **********************************************************************/
  Scene_Battle.prototype.createAmmoWindow = function() {
    this._ammoWindow = new Window_Ammo();
    this._ammoWindow.y = this._actorCommandWindow.y - this._ammoWindow.height;
    this.addWindow(this._ammoWindow);
  };
  
  /**********************************************************************
  * Méthode : createAllWindows (surcharge)
  * Fonction : ajout de l'appel à createAmmoWindow
  * Params : --
  **********************************************************************/
  var _Scene_Battle_createAllWindows = Scene_Battle.prototype.createAllWindows;
  Scene_Battle.prototype.createAllWindows = function() {
    _Scene_Battle_createAllWindows.call(this);
    this.createAmmoWindow();
  };
  
  /**********************************************************************
  * Méthode : startPartyCommandSelection (surcharge)
  * Fonction : ajoute la fermeture de la fenêtre de munition
  * Params : --
  **********************************************************************/
  var _Scene_Battle_startPartyCommandSelection = Scene_Battle.prototype.startPartyCommandSelection;
  Scene_Battle.prototype.startPartyCommandSelection = function() {
    _Scene_Battle_startPartyCommandSelection.call(this);
    this._ammoWindow.close();
  };
  
  /**********************************************************************
  * Méthode : startActorCommandSelection (surcharge)
  * Fonction : change le personnage géré par la fenêtre de munition
  * Params : --
  **********************************************************************/
  var _Scene_Battle_startActorCommandSelection = Scene_Battle.prototype.startActorCommandSelection;
  Scene_Battle.prototype.startActorCommandSelection = function() {
    _Scene_Battle_startActorCommandSelection.call(this);
    this._ammoWindow.setActor(BattleManager.actor());
  };
  
  /**********************************************************************
  * Méthode : endCommandSelection (surcharge)
  * Fonction : ajoute la fermeture de la fenêtre de munition
  * Params : --
  **********************************************************************/
  var _Scene_Battle_endCommandSelection = Scene_Battle.prototype.endCommandSelection;
  Scene_Battle.prototype.endCommandSelection = function() {
    this._ammoWindow.close();    
    _Scene_Battle_endCommandSelection.call(this);
  };
  
  /**********************************************************************
  *----------------------------------------------------------------------
  * Modification de la "classe" Game_Interpreter
  *----------------------------------------------------------------------
  **********************************************************************/
  /**********************************************************************
  * Méthode : pluginCommand (surcharge)
  * Fonction : Ajoute des commande de gestion de munition
  * Params : --
  **********************************************************************/
  var _Game_Interpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
  Game_Interpreter.prototype.pluginCommand = function(command, args) {
    _Game_Interpreter_pluginCommand.call(this, command, args);
    if(command === 'AmmoSet'){
      var actor = $gameActors.actor(Number(args[0]));
      actor.setAmmo(Number(args[1]));
    }else if(command === 'AmmoAdd'){
      var actor = $gameActors.actor(Number(args[0]));
      actor.addAmmo(Number(args[1]));
    }
  };
  
  /**********************************************************************
  *----------------------------------------------------------------------
  * Fonctions globales
  *----------------------------------------------------------------------
  **********************************************************************/
  window.outOfAmmo = function(pActorId){
    return $gameActors.actor(pActorId).getAmmo() === 0;
  };

})();


En paramètre 'ID Ammo Weapon Type', il faut mettre la liste des IDs des type d'armes, séparé par des ','

des commandes de module pour les événements, exemple :
- mettre 20 munitions pour le personage ID 1 :
AmmoSet 1 20
- retirer 1 munition sur le personnage ID 2 :
AmmoAdd 2 -1

Fonction globale pour controler si un personnage est a cours de munition (utile pour les conditions script dans un événement) :
- fonction vérifiant si lepersonnage ID 1 n'a plus de munition :
outOfAmmo(1)

Merci beaucoup ! Je vais essayer ça de suite, je suis pas sûre d'avoir tout compris, mais je pense que je comprendrai en faisant!

Bon c'est bon j'ai tout compris. Le seul hic en fait, c'est qu'il n'y a que les balles spéciales qui doivent être comptées et non les balles "normale". Puisque le principe que j'avais mis en place était que une fois les balles spéciales épuisées, le personnage repassent sur des balles normales qui elles ne sont pas comptées. Tout ça complique un peu les choses... Mais c'est pas grave puisqu'en évent avec ton plugin précédent, j'ai tout qui fonctionne. Je m'en servirai sans doute pour autre chose du coup, parce que j'aimerai bien l'exploiter.

Par contre, est-ce qu'il y a moyen que je mettre la variable que j'avais mise en place dans ton petit encadré ?

a oui, il faut faire un 'AmmoSet 1 -1', pour passer en munition infini

a oui, j'avais oublié un truc pour que ça reste en infini :

Code:

//=============================================================================
// Tonyryu_SimpleAmmo.js
//=============================================================================

/*:
 * @plugindesc Plugin permettant d'ajouter une gestion de munition simple
 * @author Tonyryu
 * @version 1.0.1
 *
 * @param Ammo name
 * @desc Nom court qui sera placé devant le nombre de munition
 * @default Muni.
 *
 * @param ID Ammo Weapon Type
 * @desc ID des types d'arme nécessitant des munitions, séparé par ,
 * @default 9
 *
 * @help http://www.tonyryudev.com/
 *
 */

/*
 * Suivi de version
 * 1.0.0 : 24/04/2016 : Tonyryu : Création plugin
 *
 */

var Imported = Imported || {};
Imported.Tonyryu_SimpleAmmo = true;

var Tonyryu = Tonyryu || {};
Tonyryu.SA = Tonyryu.SA || {};

(function() { // Définition de la fonction anonyme qui sera exécuté immédiatement, permet ainsi d'éviter d'ajouter des variables globales inutiles

  var parameters = PluginManager.parameters('Tonyryu_SimpleAmmo');
  var param_ammoName = String(parameters['Ammo name'] || 'Mun.');
  var param_ammoWeaponType = String(parameters['ID Ammo Weapon Type'] || '9');

  /**********************************************************************
  *----------------------------------------------------------------------
  * Modification de la "classe" Game_Actor
  *----------------------------------------------------------------------
  **********************************************************************/
  /**********************************************************************
  * Méthode : initialize (surcharge)
  * Fonction : permet d'ajouter des variables de gestion de munition
  * Params : --
  **********************************************************************/
  var _Game_Actor_initialize = Game_Actor.prototype.initialize;
  Game_Actor.prototype.initialize = function(actorId) {
    _Game_Actor_initialize.call(this, actorId);
    this._ammo = -1;
  };
 
  /**********************************************************************
  * Méthode : setAmmo (ajout)
  * Fonction : permet de définir le nombre de munition (-1 : infini)
  * Params : pNbAmmo : Nombre de munition
  **********************************************************************/
  Game_Actor.prototype.setAmmo = function(pNbAmmo) {
    this._ammo = pNbAmmo;
  };
 
  /**********************************************************************
  * Méthode : getAmmo (ajout)
  * Fonction : permet de récupérer le nombre de munition
  * Params : --
  **********************************************************************/
  Game_Actor.prototype.getAmmo = function() {
    return this._ammo;
  };
 
  /**********************************************************************
  * Méthode : addAmmo (ajout)
  * Fonction : permet d'ajouter un nombre de munition
  * Params : pNbAmmo : Nombre de munition
  **********************************************************************/
  Game_Actor.prototype.addAmmo = function(pNbAmmo) {
    this._ammo += (pNbAmmo || 0);
    if(this._ammo < -1)
      this._ammo = -1;
  };
 
  /**********************************************************************
  * Méthode : isWtypeAmmoEquipped (ajout)
  * Fonction : permet de vérifier si le perso est équipé d'une arme a munition
  * Params : --
  **********************************************************************/
  Game_Actor.prototype.isWtypeAmmoEquipped = function() {
    if(param_ammoWeaponType){
      param_ammoWeaponType = param_ammoWeaponType.replace(' ', '');
      var tabIdWeaponType = param_ammoWeaponType.split(',');
      for(var i= 0; i < tabIdWeaponType.length; i++){
        if(this.isWtypeEquipped(Number(tabIdWeaponType[i])))
          return true;
      }
    }
    return false;
  };
 

  /**********************************************************************
  *----------------------------------------------------------------------
  * Ajout de la "classe" Window_Ammo
  *----------------------------------------------------------------------
  **********************************************************************/
  function Window_Ammo() {
    this.initialize.apply(this, arguments);
  }

  Window_Ammo.prototype = Object.create(Window_Base.prototype);
  Window_Ammo.prototype.constructor = Window_Ammo;

  /**********************************************************************
  * Méthode : initialize
  * Fonction : initialisation de la fenêtre
  * Params : --
  **********************************************************************/
 Window_Ammo.prototype.initialize = function() {
    var width = Window_ActorCommand.prototype.windowWidth();
    var height = this.fittingHeight(1);
    Window_Base.prototype.initialize.call(this, 0, 0, width, height);
    this._actor = null;
    this.openness = 0;
  };
 
  /**********************************************************************
  * Méthode : standardPadding
  * Fonction : défini un padding standard plus petit que la normal
  * Params : --
  **********************************************************************/
  Window_Ammo.prototype.standardPadding = function() {
    return 9;
  };

  /**********************************************************************
  * Méthode : setActor
  * Fonction : permet de changer de personnage pour la gestion d'affichage
  * Params : --
  **********************************************************************/
  Window_Ammo.prototype.setActor = function(actor) {
    this._actor = actor;
    this.refresh();
    if(this._actor.isWtypeAmmoEquipped())
      this.open();
    else
      this.close();
  };

  /**********************************************************************
  * Méthode : refresh
  * Fonction : défini le contenu de l'affichage
  * Params : --
  **********************************************************************/
  Window_Ammo.prototype.refresh = function() {
    var nbAmmo = this._actor.getAmmo();
    if(nbAmmo === -1)
      this.drawTextEx(param_ammoName + ' : ∞', this.textPadding(), 0);
    else
      this.drawTextEx(param_ammoName + ' : ' + String(nbAmmo), this.textPadding(), 0);
  };


  /**********************************************************************
  *----------------------------------------------------------------------
  * Modification du "classe" Scene_Battle
  *----------------------------------------------------------------------
  **********************************************************************/
  /**********************************************************************
  * Méthode : createAmmoWindow (ajout)
  * Fonction : Ajoute la fenêtre de munition dans la scene
  * Params : --
  **********************************************************************/
  Scene_Battle.prototype.createAmmoWindow = function() {
    this._ammoWindow = new Window_Ammo();
    this._ammoWindow.y = this._actorCommandWindow.y - this._ammoWindow.height;
    this.addWindow(this._ammoWindow);
  };
 
  /**********************************************************************
  * Méthode : createAllWindows (surcharge)
  * Fonction : ajout de l'appel à createAmmoWindow
  * Params : --
  **********************************************************************/
  var _Scene_Battle_createAllWindows = Scene_Battle.prototype.createAllWindows;
  Scene_Battle.prototype.createAllWindows = function() {
    _Scene_Battle_createAllWindows.call(this);
    this.createAmmoWindow();
  };
 
  /**********************************************************************
  * Méthode : startPartyCommandSelection (surcharge)
  * Fonction : ajoute la fermeture de la fenêtre de munition
  * Params : --
  **********************************************************************/
  var _Scene_Battle_startPartyCommandSelection = Scene_Battle.prototype.startPartyCommandSelection;
  Scene_Battle.prototype.startPartyCommandSelection = function() {
    _Scene_Battle_startPartyCommandSelection.call(this);
    this._ammoWindow.close();
  };
 
  /**********************************************************************
  * Méthode : startActorCommandSelection (surcharge)
  * Fonction : change le personnage géré par la fenêtre de munition
  * Params : --
  **********************************************************************/
  var _Scene_Battle_startActorCommandSelection = Scene_Battle.prototype.startActorCommandSelection;
  Scene_Battle.prototype.startActorCommandSelection = function() {
    _Scene_Battle_startActorCommandSelection.call(this);
    this._ammoWindow.setActor(BattleManager.actor());
  };
 
  /**********************************************************************
  * Méthode : endCommandSelection (surcharge)
  * Fonction : ajoute la fermeture de la fenêtre de munition
  * Params : --
  **********************************************************************/
  var _Scene_Battle_endCommandSelection = Scene_Battle.prototype.endCommandSelection;
  Scene_Battle.prototype.endCommandSelection = function() {
    this._ammoWindow.close();   
    _Scene_Battle_endCommandSelection.call(this);
  };
 
  /**********************************************************************
  *----------------------------------------------------------------------
  * Modification de la "classe" Game_Interpreter
  *----------------------------------------------------------------------
  **********************************************************************/
  /**********************************************************************
  * Méthode : pluginCommand (surcharge)
  * Fonction : Ajoute des commande de gestion de munition
  * Params : --
  **********************************************************************/
  var _Game_Interpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
  Game_Interpreter.prototype.pluginCommand = function(command, args) {
    _Game_Interpreter_pluginCommand.call(this, command, args);
    if(command === 'AmmoSet'){
      var actor = $gameActors.actor(Number(args[0]));
      actor.setAmmo(Number(args[1]));
    }else if(command === 'AmmoAdd'){
      var actor = $gameActors.actor(Number(args[0]));
      actor.addAmmo(Number(args[1]));
    }
  };
 
  /**********************************************************************
  *----------------------------------------------------------------------
  * Fonctions globales
  *----------------------------------------------------------------------
  **********************************************************************/
  window.outOfAmmo = function(pActorId){
    return $gameActors.actor(pActorId).getAmmo() === 0;
  };

})();


Ah ok, ah bah donc du coup, je teste tout ça demain et je te dis. Merci beaucoup en tous cas !

Je double poste au cas où tu aurais vu mon message d'hier, histoire d'être sûre que tu vois celui-ci.
Bon, il y a un petit soucis. Je serai pas étonnée que ça soit lié à ta dernière correction du reste. C'est que le nombre des munitions restantes s'écrit sur le nombre précédent:


Edit: autre soucis que j'ai relevé, c'est que si par exemple j'ai une arme à balles spéciales et qu'il me reste 15 munitions, admettons que je veuille les économiser et que je repasse sur un pistolet simple donc avec des balles infinies. Jusque là pas de soucis, mes munitions restent à 15, en revanche le nombre de munitions affiché, au lieu d'être infini sera 15.
J'y connais rien en code, mais tu as parlé d'identifier le type d'arme par l'ID, en fait il faudrait sans doute identifier l'arme tout court et non son type pour que la variable soit conservée, non ? Désolée si je viens de dire une bêtise, mais j'aurai tenté

Re-edit: ah bah non c'était une ânerie que j'ai dite en fait, parce que l'ID de l'arme tout court ne suffit pas dans la mesure où le joueur peut en avoir plusieur du même type chargé avec des balles différentes.

pour la superposition, c'est normal, j'ai oublié de vider le contenu de la fenêtre avant de réécrire.
Pour la gestion des types de munition, je vais ajouter ce qu'il faut. Je te fait ça aujourd'hui.

Edit, il me semblait au vue de tes events, que tu supprimer ton pistolet simple de ton inventaire et tu mettais un pistolet spécial à la place, lors de l'utilisation d'un objet munition. Ce n'est plus le cas maintenant?

arf j'ai édité avant de voir ton ton message.

Non, je ne supprime que le pistolet à recharge, pas le pistolet normal (celui de base du jeu) et pour l'instant je n'ai créé qu'un type de balle spéciales mais le joueurs pourra en créer beaucoup plus, il pourra donc conserver plusieurs pistolets à recharges sur lui avec des balles de types différents. L'évent que tu as vu concernait le cas du chargement du pistolet à recharge avec des balles de sommeil.

Edit: M'enfin t'embête pas outre mesure, j'ai pas envie que tu passes des heures à faire ça, si on ne voit pas le nombre c'est pas grave....

non, t'en fait pas, ça m'amuse de faire ça. Je vais du coup gérer une liste de munition au niveau des perso, et des commandes pour pouvoir indiquer quel type de munition on utilise.

et si "simplement" (en fait je ne sais pas si c'est simple ou pas... ) le créateur du jeu (moi quoi ...) pouvait sur l'interface du plugin, entrer pour chaque arme qu'il souhaite le nom de la variable de munitions associée à afficher. D'ailleurs, j'ai modifier le nom de ma variable "nb de balles" en "nb de balles de sommeil" après t'avoir répondu...

Je trouve ce topic vraiment intéressant, car nous avons en revu du ce qu'il faut faire et de ce qu'il ne faut pas faire dans le cadre d'un développement logiciel.

En effet, pour la première demande consistant à gérer le remplacement du skill d'attaque par un autre, on est passé par une expression du besoin clair et une spécification fonctionnelle validée, ce qui a conduit à une analyse technique et un développement propre répondant à la demande.

Et sur la seconde partie, je suis parti d'un simple "ça serait bien d'avoir les munitions d'affichées", et je suis parti bille entête sur le développement, ce qui implique du tatonement, aucune feuille de test, des manques de fonctionnalité, etc...

Et pour ces 2 aspects, je souhaiterai réellement que les gens de passage sur ce topic, prennent le temps de le lire dans son intégralité

Et pour le groupe d'enfant que tu encadres, je pense que c'est une notion importante à intégrer.

Et l'on va donc reprendre la mise en place de l'affichage des munitions, dans une ligne plus structurée. Je te propose donc de me détailler le besoin, vis à vis de cette gestion des munitions dans ton jeu, le façon détaillé.

Et si si, on va se faire ça tranquillement, et ça va fonctionner au poil

Je te fais ça ce soir, parce que là je ne peux pas m'y mettre sérieusement, j'ai trop de "parasites" autour de moi (c'est pas des enfants hein ... sinon je dirai pas ça XD)

Je suis partie dans une réflexion très alambiquée avant de me rendre compte qu'en fait non la demande n'est pas si compliquée que ça.

Rappel du principe:
- Parmi les armes à munitions du type pistolet, arc et que sais-je... certaines on la particularité de recevoir des munitions spéciales. Ces munitions sont des objets. Si l'arme est équipée et que l'objet est utilisé (en dehors d'un combat), l'arme est chargée et change de type. Une arme de ce type non chargée aura des munitions à l'infini. Seules les balles spéciales ne sont pas infinies.

Ex:
- Bob a équipé un pistolet à recharge.
- Bob a des balles de sommeil dans son inventaire.
- Bob utilise les balles de sommeil (ce sont des pack de 20)
- Le "pistolet à recharge" de Bob devient un "pistolet à recharge de sommeil" contenant 20 balles de sommeil (techniquement, un pistolet à recharge de sommeil est placé dans son inventaire, son pistolet à recharge est supprimé, le pistolet à recharge de sommeil est équipé, la variable de balle de sommeil est initialisée)
- Bob part combattre le grand Magichien (qui est très résistant il faut le dire) au bout de 20 tours, Bob n'a plus de balle de sommeil (bah oui j'avais dit qu'il était très résistant...)
- Le "pistolet à recharge de sommeil" est remplacé par un "pistolet à recharge"
- Si Bob veut changer de balle et prendre des balles de confusion alors que ses munitions ne sont pas épuisées, il aura qu'à s'acheter un autre pistolet à recharge parce que franchement je vais pas me taper toutes les combinaisons possibles en évent. Donc Bob, il a qu'à gagner des sous !
- Du coup Bob va se retrouver avec plusieurs armes différentes dans son inventaire, il doit donc y avoir autant de variables de balle que de balle différentes.
- La seule chose que pourra éventuellement faire Bob, c'est recharger son arme avec le type de balles qu'il y avait dessus avant.

-Pour ce qui est de l'affichage en terme d'apparence, y a rien à changer, ce que tu as fait va très bien.
-Pour le contenu il faut que:
- si arme dont l'ID est X est équipée => la fenêtre affiche la variable dont l'ID est Y
- ceci étant paramétrable par le créateur dans la configuration du plugin
- on se fiche éperdument d'afficher les munitions pour les armes qui ont des munitions à l'infini

Voilou, j'espère que tu as les éléments qu'il te faut.

Alors, je ne t'ai pas oublié, c'est que cette semaine au boulot, c'est vraiment une semaine de merde et que comme ta demande nécessite une reflexion correcte, je prend mon temps pour m'y mettre. Surtout que quitte a faire un système de gestion de munition avec des capacités spécifiques sur des armes, j'essai de le réfléchir pour qu'il soit parfait pour ton utilisation, mais également exploitable pour d'autre.

Donc, j'y pense tous les jours, mais j'ai encore rien mis sur papier. Ca va venir.

t'inquiete pas rien ne presse