Partagez
Aller en bas
avatar
Rel
Membre

Nombre de messages : 352
Localisation : Le Mans, Sarthes
Distinction : aucune
Date d'inscription : 18/01/2013

[Résolu] Problème avec Party System de Yanfly

le Jeu 13 Juin 2013 - 21:08
Voila j'ai un problème avec le script de Yanfly: Party System
Spoiler:

Code:
# ================================================= =============================
#
# ▼ Yanfly moteur Ace - Système Parti v1.08
# - Dernière mise à jour: 2012.01.23
# - Niveau: Normal
# - Nécessite: n / a
#
# ================================================= =============================

$ Importé = {} si imported.nil $?
$ Importé ["YEA-PartySystem"] = true

# ================================================= =============================
# ▼ Mises à jour
# = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - =
# 2012.01.23 - Bug fixé: les membres du Parti sont maintenant réarrangées lorsque vous venez d'ajouter.
# 2012.01.14 - Nouvelle fonctionnalité: Battle variable maximal de membres ajouté.
# 2012.01.07 - Bug corrigé: Erreur avec les membres de l'élimination.
# 2012.01.05 - Bug corrigé: Évasion compétences / item effets aucun Chiffres de plus que la mort.
# 2011.12.26 - Mise à jour de compatibilité: New Game +
# 2011.12.17 - Spriteset_Battle jour avoir mis à jour compte sprite.
# 2011.12.13 - Mise à jour pour offrir un meilleur affichage visuel lorsque plus de 5 pièces
Nombre d'équipements sont équipés sur un acteur à la fois.
# 2011.12.05 - Ajout d'une fonctionnalité pour afficher les faces du Parti Sélectionnez Fenêtre.
# - Correction d'un bug qui ne rafraîchit pas la chenille lorsque de nouveaux membres
# Joindre à la fête.
# 2011.12.04 - Commencez Script et finis.
#
# ================================================= =============================
# ▼ Présentation
# = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - =
# RPG Maker VX Ace est livré avec un système de parti très agréable. Cependant, la modification du
# Nombre maximum de membres n'est pas possible sans l'aide d'un script. Cette
# Script vous permet la possibilité de modifier le nombre maximal de membres du parti,
# Modifier les taux d'EXP et / ou ouvrir un menu de fête séparée (si désiré). En
# Plus de cela, vous pouvez verrouiller la position des acteurs au sein d'un parti et
# Exigent d'autres acteurs pour faire partie du groupe actif avant de poursuivre.
#
# ================================================= =============================
# ▼ Instructions
# = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - =
# Pour installer ce script, ouvrez votre éditeur de script et copiez / collez ce script
# Pour une fente ouverte ci-dessous ▼ Matériaux / 素材 mais surtout ▼ principales. N'oubliez pas de sauvegarder.
#
# ------------------------------------------------- ----------------------------
# Script appelle - Ces commandes sont utilisées avec des appels de script.
# ------------------------------------------------- ----------------------------
# * IMPORTANT * Ces appels de script nécessitent le nouveau menu de fête doit être activé pour
# Utiliser. Sinon, rien ne se passera.
#
# Lock_actor (x)
# Unlock_actor (x)
# Cela va bloquer acteur x dans sa position actuelle au sein du parti, si l'acteur est
# Dans la partie en cours. L'acteur est incapable de changer de position et doit rester
# Dans cette position jusqu'à ce que le verrou est supprimé. Utilisez l'appel du script de déverrouillage
# Supprimer le statut verrouillé. Ce script nécessite l'acteur à avoir rejoint et
# Dans la partie en cours avant l'appel du script fonctionnera.
#
# Require_actor (x)
# Unrequire_actor (x)
# Cela entraînera le parti d'exiger acteur x pour continuer. Si l'
# Acteur n'est pas dans la partie en cours, mais se trouve dans la partie réserve, le menu de fête
# S'ouvrira et demandera au joueur d'ajouter l'acteur requis dans le parti
# Avant de pouvoir continuer. Cet appel de script ne fonctionnera pas à moins que le
# Acteur spécifique a rejoint le parti, que ce soit dans le courant ou la réserve.
#
# Call_party_menu
# Cela permettra d'ouvrir le menu de fête. Cet appel de script nécessite pour le parti
# Menu pour être activé pour utiliser.
#
# ================================================= =============================
# ▼ Compatibilité
# = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - =
# Ce script est fait strictement pour RPG Maker VX Ace. Il est hautement improbable que
# Il fonctionnera avec RPG Maker VX sans réglage.
#
# ================================================= =============================

Module YEA
  Module PARTY
    
    # = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = -
    # - Paramètres de la Fête -
    # = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = -
    # Dans cette section, vous pouvez régler les paramètres généraux du parti pour votre jeu
    # Tels que le montant maximal de membres et autres joyeusetés, le taux d'EXP pour
    # Partis membres de la réserve, etc
    # = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = -
    MAX_BATTLE_MEMBERS = 5 membres # maximum de parti. Par défaut: 4
    SPLIT_EXP = false # Divise EXP avec d'autres membres du parti.
    RESERVE_EXP_RATE = 0.50 # Réserve EXP Rate. Par défaut: 1.00
    
    # Si vous voulez être en mesure de modifier le nombre maximal de membres de bataille
    # Au milieu de votre jeu, définir cette constante à une variable ID. Si
    # Cette variable ID est un nombre supérieur à 0, la variable qui détermine
    # Le nombre maximal actuel de membres de bataille. Soyez prudent lorsque vous utilisez
    # Ceci pendant la bataille.
    MAX_MEMBERS_VARIABLE = 0
    
    # = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = -
    # - Réglages du menu Party -
    # = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = -
    # Cette section contient divers réglages du menu pour ceux qui souhaitent utiliser un
    # Menu distinct pour le système des partis. Ici, ajustez l'ordre de commande de menu,
    # Icônes utilisées, et d'autres paramètres.
    # = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = -
    ENABLE_MENU = true # Permet menu de fête. Défaut: faux
    COMMANDES = [# L'ordre dans lequel les éléments du menu sont visibles.
    # [: Commande "Affichage"],
      [: Changement, "changement",],
      [: Supprimer "Supprimer"],
      [: Revenir, "Revert"],
      [: Finition, "Finish"],
    ] # Ne pas enlever cela.
    COMMAND_ALIGN = 1 # 0: Aligner à gauche, 1: Centre Aligner 2: Aligné à droite
    
    # Ces paramètres sont utilisés ici pour la fenêtre en haut à droite: le Parti Sélectionnez
    # Fenêtre où le joueur choisit un membre d'échanger ou de le supprimer.
    PARTY_FONT_SIZE = 20 # taille de la police utilisée pour les noms de membres du parti.
    LOCK_FIRST_ACTOR = false # Verrouiller le premier acteur par défaut?
    LOCKED_ICON = 125 # Icône utilisée pour les membres verrouillées.
    REQUIRED_ICON = 126 # Icône utilisée pour les membres requis.
    EMPTY_TEXT = "vide-" # texte utilisé lorsqu'un membre n'est pas présent.
    DISPLAY_FACE = false # Display confrontée au lieu de sprites?
    
    # Ces paramètres sont utilisés ici pour la fenêtre en bas à gauche: la liste du parti
    # Fenêtre où le joueur choisit un membre à remplacer.
    REMOVE_ICON = 185 # Icône utilisé pour enlever membres.
    REMOVE_TEXT = "-Remove-" # texte utilisé pour la commande de membre supprimer.
    ACTOR_Y_BUFFER = 12 # Montant du graphique acteur être ajustée par.
    
    # Ces paramètres sont utilisés ici pour la fenêtre en bas à droite: le statut de parti
    # Fenêtre où informations sur un acteur sélectionné est affiché.
    NO_DATA = "- Aucune donnée -" # texte utilisé pour quand aucun acteur est affiché.
    IN_PARTY_COLOUR color = # 6 du texte utilisé par les membres du parti.
    STAT_FONT_SIZE = 20 # taille de la police utilisée pour les stats.
    EQUIP_TEXT = "Equipment" # texte utilisé pour afficher des équipements.
    
  end # PARTY
end # YEA

# ================================================= =============================
# ▼ Editting rien passé ce point peut potentiellement résulter en cause
# Endommager l'ordinateur, de l'incontinence, l'explosion de la tête de l'utilisateur, le coma, la mort et / ou
# Halitose ainsi modifier à vos propres risques.
# ================================================= =============================

# ================================================= =============================
# ■ Icône
# ================================================= =============================

Module Icône
  
  # ------------------------------------------------- -------------------------
  # Self.locked_party
  # ------------------------------------------------- -------------------------
  def self.locked_party; retour YEA :: PARTY :: LOCKED_ICON; fin
  
  # ------------------------------------------------- -------------------------
  # Self.required_party
  # ------------------------------------------------- -------------------------
  def self.required_party; retour YEA :: PARTY :: REQUIRED_ICON; fin
  
  # ------------------------------------------------- -------------------------
  # Self.remove_party
  # ------------------------------------------------- -------------------------
  def self.remove_party; retour YEA :: PARTY :: REMOVE_ICON; fin
    
end # Icône

# ================================================= =============================
# ■ Variable
# ================================================= =============================

Module Variable
  
  # ------------------------------------------------- -------------------------
  # Self.max_battle_members
  # ------------------------------------------------- -------------------------
  self.max_battle_members def
    Par défaut = YEA :: PARTY :: MAX_BATTLE_MEMBERS
    retourner défaut si YEA :: PARTY :: MAX_MEMBERS_VARIABLE <= 0
    retourner défaut si $ game_variables [YEA :: PARTY :: MAX_MEMBERS_VARIABLE] <= 0
    return $ game_variables [YEA :: PARTY :: MAX_MEMBERS_VARIABLE]
  fin
  
end # Variable

# ================================================= =============================
# ■ Numérique
# ================================================= =============================

classe numérique
  
  # ------------------------------------------------- -------------------------
  # Nouvelle méthode: group_digits
  # ------------------------------------------------- -------------------------
  à moins que $ importé ["YEA-CoreEngine"]
  groupe def; self.to_s de retour; fin
  end # $ importé ["YEA-CoreEngine"]
    
end # Numérique

# ================================================= =============================
# ■ Game_Actor
# ================================================= =============================

classe Game_Actor <Game_Battler
  
  # ------------------------------------------------- -------------------------
  Variables d'instance # publics
  # ------------------------------------------------- -------------------------
  attr_accessor: verrouillé
  attr_accessor: obligatoire
  
  # ------------------------------------------------- -------------------------
  # Méthode d'alias: setup
  # ------------------------------------------------- -------------------------
  alias game_actor_setup_ps configuration
  def setup (actor_id)
    game_actor_setup_ps (actor_id)
    @ Verrouillé = false
    @ Requis = false
  fin
  
  # ------------------------------------------------- -------------------------
  # Écraser méthode: final_exp_rate
  # ------------------------------------------------- -------------------------
  def final_exp_rate
    n = EXR * (? battle_member 1: reserve_members_exp_rate)
    if $ game_party.in_battle
      n / = [game_party.battle_members.size $, 1]. max si YEA :: PARTY :: SPLIT_EXP
    fin
    retourner n
  fin
  
  # ------------------------------------------------- -------------------------
  # Écraser méthode: reserve_members_exp_rate
  # ------------------------------------------------- -------------------------
  def reserve_members_exp_rate
    $ Data_system.opt_extra_exp? YEA :: PARTY :: RESERVE_EXP_RATE: 0
  fin
  
end # Game_Actor

# ================================================= =============================
# ■ Game_Party
# ================================================= =============================

classe Game_Party <Game_Unit
  
  # ------------------------------------------------- -------------------------
  Variables d'instance # publics
  # ------------------------------------------------- -------------------------
  attr_accessor: battle_members_array
  
  # ------------------------------------------------- -------------------------
  # Méthode d'alias: initialiser
  # ------------------------------------------------- -------------------------
  alias game_party_initialize_ps initialiser
  def initialize
    game_party_initialize_ps
    @ Battle_members_array = nil
  fin
  
  # ------------------------------------------------- -------------------------
  # Écraser méthode: max_battle_members
  # ------------------------------------------------- -------------------------
  max_battle_members def; Variable.max_battle_members de retour; finaux
  
  # ------------------------------------------------- -------------------------
  # Méthode d'alias: setup_starting_members
  # ------------------------------------------------- -------------------------
  alias setup_starting_members_ps setup_starting_members
  setup_starting_members def
    setup_starting_members_ps
    initialize_battle_members
    le retour à moins YEA :: PARTY :: LOCK_FIRST_ACTOR
    retourner si les membres [0]. néant?
    membres [0]. verrouillé = true
  fin
  
  # ------------------------------------------------- -------------------------
  # Méthode d'alias: setup_battle_test_members
  # ------------------------------------------------- -------------------------
  alias setup_battle_test_members_ps setup_battle_test_members
  setup_battle_test_members def
    setup_battle_test_members_ps
    le retour à moins YEA :: PARTY :: LOCK_FIRST_ACTOR
    retourner si les membres [0]. néant?
    membres [0]. verrouillé = true
  fin
  
  # ------------------------------------------------- -------------------------
  # Écraser méthode: battle_members
  # ------------------------------------------------- -------------------------
  battle_members def
    initialize_battle_members si initialize_battle_members?
    array = []
    pour actor_id dans @ battle_members_array
      pause si array.size> max_battle_members
      prochaine si actor_id.nil?
      prochaine si $ game_actors [actor_id]. néant?
      prochaine à moins que $ game_actors [actor_id]. exister?
      Array.push ($ game_actors [actor_id])
    fin
    return array
  fin
  
  # ------------------------------------------------- -------------------------
  # Nouvelle méthode: initialize_battle_members?
  # ------------------------------------------------- -------------------------
  initialize_battle_members def?
    return true if@battle_members_array.nil?
    return@battle_members_array.size! = max_battle_members
  fin
  
  # ------------------------------------------------- -------------------------
  # Nouvelle méthode: initialize_battle_members
  # ------------------------------------------------- -------------------------
  initialize_battle_members def
    @ Battle_members_array = []
    for i in 0 ... max_battle_members
      @ Battle_members_array.push (@ acteurs [i]) unless @ acteurs [i]. Néant?
      @ Battle_members_array.push (0) si @ acteurs [i]. Néant?
    fin
    $ Game_player.refresh
  fin
  
  # ------------------------------------------------- -------------------------
  # Méthode d'alias: add_actor
  # ------------------------------------------------- -------------------------
  alias game_party_add_actor_ps add_actor
  def add_actor (actor_id)
    game_party_add_actor_ps (actor_id)
    retourner if@battle_members_array.include? (actor_id)
    retourner unless@battle_members_array.include? (0)
    index = @ battle_members_array.index (0)
    @ Battle_members_array [index] = actor_id
    $ Game_player.refresh
    $ Game_map.need_refresh = true
    rearrange_actors
  fin
  
  # ------------------------------------------------- -------------------------
  # Méthode d'alias: remove_actor
  # ------------------------------------------------- -------------------------
  alias game_party_remove_actor_ps remove_actor
  def remove_actor (actor_id)
    game_party_remove_actor_ps (actor_id)
    retourner unless@battle_members_array.include? (actor_id)
    index = @ battle_members_array.index (actor_id)
    @ Battle_members_array [index] = 0
    $ Game_player.refresh
    $ Game_map.need_refresh = true
    rearrange_actors
  fin
  
  # ------------------------------------------------- -------------------------
  # Nouvelle méthode: rearrange_actors
  # ------------------------------------------------- -------------------------
  def rearrange_actors
    initialize_battle_members if@battle_members_array.nil?
    array = []
    pour actor_id dans @ battle_members_array
      prochaine si [0, nil]. comprendre? (actor_id)
      prochaine si $ game_actors [actor_id]. néant?
      Array.push (actor_id)
    fin
    pour actor_id dans @ acteurs
      prochaine si array.include? (actor_id)
      prochaine si $ game_actors [actor_id]. néant?
      Array.push (actor_id)
    fin
    @ Acteurs = array
  fin
  
end # Game_Party

# ================================================= =============================
# ■ Game_Interpreter
# ================================================= =============================

classe Game_Interpreter
  
  # ------------------------------------------------- -------------------------
  # Nouvelle méthode: lock_actor
  # ------------------------------------------------- -------------------------
  def lock_actor (actor_id)
    le retour à moins YEA :: PARTY :: ENABLE_MENU
    acteur = $ game_actors [actor_id]
    le retour à moins $ game_party.battle_members.include? (actor.id)
    actor.locked = true
  fin
  
  # ------------------------------------------------- -------------------------
  # Nouvelle méthode: unlock_actor
  # ------------------------------------------------- -------------------------
  def unlock_actor (actor_id)
    le retour à moins YEA :: PARTY :: ENABLE_MENU
    acteur = $ game_actors [actor_id]
    le retour à moins $ game_party.battle_members.include? (actor.id)
    actor.locked = false
  fin
  
  # ------------------------------------------------- -------------------------
  # Nouvelle méthode: require_actor
  # ------------------------------------------------- -------------------------
  def require_actor (actor_id)
    le retour à moins YEA :: PARTY :: ENABLE_MENU
    retourner si $ game_system.formation_disabled
    acteur = $ game_actors [actor_id]
    le retour à moins $ game_party.all_members.include? (acteur)
    actor.required = true
    call_party_menu moins que $ game_party.battle_members.include? (acteur)
  fin
  
  # ------------------------------------------------- -------------------------
  # Nouvelle méthode: unrequire_actor
  # ------------------------------------------------- -------------------------
  def unrequire_actor (actor_id)
    le retour à moins YEA :: PARTY :: ENABLE_MENU
    retourner si $ game_system.formation_disabled
    acteur = $ game_actors [actor_id]
    le retour à moins $ game_party.all_members.include? (acteur)
    actor.required = false
    call_party_menu moins que $ game_party.battle_members.include? (acteur)
  fin
  
  # ------------------------------------------------- -------------------------
  # Nouvelle méthode: call_party_menu
  # ------------------------------------------------- -------------------------
  def call_party_menu
    le retour à moins YEA :: PARTY :: ENABLE_MENU
    retourner si $ game_system.formation_disabled
    SceneManager.call (Scene_Party)
  fin
  
end # Game_Interpreter

# ================================================= =============================
# ■ Spriteset_Battle
# ================================================= =============================

classe Spriteset_Battle
  
  # ------------------------------------------------- -------------------------
  # Écraser méthode: create_actors
  # ------------------------------------------------- -------------------------
  def create_actors
    Total = $ game_party.max_battle_members
    @ Actor_sprites = Array.new (total) {Sprite_Battler.new (@ viewport1)}
  fin
  
end # Spriteset_Battle

# ================================================= =============================
# ■ Window_PartyMenuCommand
# ================================================= =============================

classe Window_PartyMenuCommand <Window_Command
  
  # ------------------------------------------------- -------------------------
  # Window_width
  # ------------------------------------------------- -------------------------
  def window_width; retour 160; fin
  
  # ------------------------------------------------- -------------------------
  # Visible_line_number
  # ------------------------------------------------- -------------------------
  def visible_line_number; 4; fin
  
  # ------------------------------------------------- -------------------------
  # Alignement
  # ------------------------------------------------- -------------------------
  alignement def
    retourner Menu.command_window_align si $ importé ["YEA-AceMenuEngine"]
    retourner YEA :: PARTY :: COMMAND_ALIGN
  fin
  
  # ------------------------------------------------- -------------------------
  # Scène
  # ------------------------------------------------- -------------------------
  scène def; retour SceneManager.scene; fin
  
  # ------------------------------------------------- -------------------------
  # Make_command_list
  # ------------------------------------------------- -------------------------
  def make_command_list
    pour la commande à Yea :: PARTY :: COMMANDES
      commande de cas [0]
      lorsque le changement, la: enlever,: revenir
        add_command (commande [1], la commande [0])
      lorsque: finition
        add_command (commande [1], la commande [0], enable_cancel?)
      d'autre; prochaine
      fin
    fin
  fin
  
  # ------------------------------------------------- -------------------------
  # Process_cancel
  # ------------------------------------------------- -------------------------
  def process_cancel
    sauf enable_cancel?
      Sound.play_buzzer
      retour
    fin
    Super
  fin
  
  # ------------------------------------------------- -------------------------
  # In_party?
  # ------------------------------------------------- -------------------------
  def in_party? (acteur)
    return $ game_party.battle_members.include? (acteur)
  fin
  
  # ------------------------------------------------- -------------------------
  # Enable_cancel?
  # ------------------------------------------------- -------------------------
  def enable_cancel?
    return false si $ game_party.battle_members.size <= 0
    pour l'acteur en $ game_party.all_members
      prochaine si in_party? (acteur)
      return false si actor.required
      return false si actor.locked
    fin
    return true
  fin
  
end # Window_PartyMenuCommand

# ================================================= =============================
# ■ Window_PartySelect
# ================================================= =============================

classe Window_PartySelect <Window_Selectable
  
  # ------------------------------------------------- -------------------------
  # Initialiser
  # ------------------------------------------------- ------------------------
  def initialize (command_window)
    @ Command_window = command_window
    Super (160, 0, window_width, fitting_height (visible_line_number))
    sélectionner (0)
    désactiver
    Actualiser
  fin
  
  # ------------------------------------------------- -------------------------
  # Col_max
  # ------------------------------------------------- -------------------------
  def col_max; return $ game_party.max_battle_members; fin
  
  # ------------------------------------------------- -------------------------
  # Item_max
  # ------------------------------------------------- -------------------------
  def item_max; return $ game_party.max_battle_members; fin
  
  # ------------------------------------------------- -------------------------
  # Window_width
  # ------------------------------------------------- -------------------------
  def window_width; Graphics.width de retour - 160; fin
  
  # ------------------------------------------------- -------------------------
  # Visible_line_number
  # ------------------------------------------------- -------------------------
  def visible_line_number; 4; fin
  
  # ------------------------------------------------- -------------------------
  # Item_rect
  # ------------------------------------------------- -------------------------
  def item_rect (index)
    rect = Rect.new
    rect.width = contents.width / item_max
    rect.height = contents.height
    rect.x = index * rect.width
    rect.y = 0
    retourner rect
  fin
  
  # ------------------------------------------------- -------------------------
  # Refresh
  # ------------------------------------------------- -------------------------
  def refresh
    make_item_list
    create_contents
    draw_all_items
  fin
  
  # ------------------------------------------------- -------------------------
  # Make_item_list
  # ------------------------------------------------- -------------------------
  def make_item_list
    @ Data = $ game_party.battle_members_array.clone
  fin
  
  # ------------------------------------------------- -------------------------
  # Draw_item
  # ------------------------------------------------- -------------------------
  def draw_item (index)
    acteur = $ game_actors [@ data [index]]
    rect = item_rect (index)
    si actor.nil?
      draw_empty (rect.clone)
      retour
    fin
    dx = rect.width / 2
    dy = rect.height - 16
    draw_actor_face (acteur, rect.x, rect.y) si display_face?
    draw_actor_graphic (acteur, rect.x + dx, dy rect.y +) à moins display_face?
    draw_actor_name (acteur, rect)
    draw_locked_icon (acteur, rect)
    draw_required_icon (acteur, rect)
  fin
  
  # ------------------------------------------------- -------------------------
  # Display_face?
  # ------------------------------------------------- -------------------------
  def display_face?
    retourner YEA :: PARTY :: DISPLAY_FACE
  fin
  
  # ------------------------------------------------- -------------------------
  # Draw_empty
  # ------------------------------------------------- -------------------------
  def draw_empty (rect)
    color = Color.new (0, 0, 0, translucent_alpha / 2)
    rect.x + = 2
    rect.y + = 2
    rect.width - = 4
    rect.height - = 4
    contents.fill_rect (rect, couleur)
    reset_font_settings
    change_color (system_color)
    text = YEA :: PARTY :: EMPTY_TEXT
    draw_text (rect, texte, 1)
    reset_font_settings
  fin
  
  # ------------------------------------------------- -------------------------
  # Draw_actor_name
  # ------------------------------------------------- -------------------------
  def draw_actor_name (acteur, rect)
    contents.font.size = YEA :: PARTY :: PARTY_FONT_SIZE
    change_color (normal_color, actor.exist?)
    draw_text (rect.x +4, rect.y, rect.width-8, line_height, actor.name, 1)
  fin
  
  # ------------------------------------------------- -------------------------
  # Draw_face
  # ------------------------------------------------- -------------------------
  def draw_face (face_name, face_index, dx, dy, enabled = true)
    bitmap = Cache.face (face_name)
    ps = [96, item_rect (0). largeur 4]. min
    rect = Rect.new (face_index% 4 * 96, face_index / 4 * 96, DW, 92)
    contents.blt (dx +2, +2 dy, bitmap, rect, a permis à 255: translucent_alpha)
    bitmap.dispose
  fin
  
  # ------------------------------------------------- -------------------------
  # Draw_locked_icon
  # ------------------------------------------------- -------------------------
  def draw_locked_icon (acteur, rect)
    le retour à moins actor_locked? (acteur)
    draw_icon (Icon.locked_party, rect.x + rect.width-26, rect.height - 26)
  fin
  
  # ------------------------------------------------- -------------------------
  # Draw_required_icon
  # ------------------------------------------------- -------------------------
  def draw_required_icon (acteur, rect)
    revenir si actor_locked? (acteur)
    le retour à moins actor_required? (acteur)
    draw_icon (Icon.required_party, rect.x + rect.width-26, rect.height - 26)
  fin
  
  # ------------------------------------------------- -------------------------
  # Actor_locked?
  # ------------------------------------------------- -------------------------
  def actor_locked (acteur);? revenir actor.locked; fin
  
  # ------------------------------------------------- -------------------------
  # Actor_required?
  # ------------------------------------------------- -------------------------
  def actor_required? (acteur)
    return false si actor.locked
    retourner actor.required
  fin
  
  # ------------------------------------------------- -------------------------
  # Current_item_enabled?
  # ------------------------------------------------- -------------------------
  def current_item_enabled;? permettre (@ data [index]);? fin
  
  # ------------------------------------------------- -------------------------
  # Permettre?
  # ------------------------------------------------- -------------------------
  def enable? (point)
    case@command_window.current_symbol
    lorsque: changement
      return true si item.nil?
      return true si l'article == 0
    lorsque: supprimer
      return false si item.nil?
      return false si l'article == 0
    fin
    acteur = $ game_actors [Article]
    return false si actor.locked
    return false si actor.required
    return true
  fin
  
  # ------------------------------------------------- -------------------------
  # Process_handling
  # ------------------------------------------------- -------------------------
  def process_handling
    le retour à moins ouvert? && Actifs
    retourner process_ok si ok_enabled? && Input.trigger? (: C)
    retourner process_cancel si cancel_enabled? && Input.trigger? (: B)
    retourner process_pagedown si poignée? (: pagedown) && Input.repeat? (R)
    retourner process_pageup si poignée? (: PAGEUP)? && Input.repeat (: L)
  fin
  
  # ------------------------------------------------- -------------------------
  # Cur_actor
  # ------------------------------------------------- -------------------------
  def cur_actor
    actor_id = @ data [index]
    return $ game_actors [actor_id]
  fin
  
  # ------------------------------------------------- -------------------------
  # Prev_actor
  # ------------------------------------------------- -------------------------
  def prev_actor
    id = index == 0? @ Data.size - 1: indice - 1
    actor_id = @ data [id]
    return $ game_actors [actor_id]
  fin
  
  # ------------------------------------------------- -------------------------
  # Next_actor
  # ------------------------------------------------- -------------------------
  def next_actor
    id = index == @ data.size - 1? 0: index + 1
    actor_id = @ data [id]
    return $ game_actors [actor_id]
  fin
  
  # ------------------------------------------------- -------------------------
  # Process_pageup
  # ------------------------------------------------- -------------------------
  def process_pageup
    permettre = true
    permettre = false si! prev_actor.nil? && Prev_actor.locked
    permettre = false si! cur_actor.nil? && Cur_actor.locked
    Sound.play_buzzer moins permettre
    Si Autoriser
      Super
      activer
      select (index == 0 @ data.size - 1: index - 1)
    fin
  fin
  
  # ------------------------------------------------- -------------------------
  # Process_pagedown
  # ------------------------------------------------- -------------------------
  def process_pagedown
    permettre = true
    permettre = false si! next_actor.nil? && Next_actor.locked
    permettre = false si! cur_actor.nil? && Cur_actor.locked
    Sound.play_buzzer moins permettre
    Si Autoriser
      Super
      activer
      select (index == @ data.size - 1 0: index + 1)
    fin
  fin
  
  # ------------------------------------------------- -------------------------
  # Item
  # ------------------------------------------------- -------------------------
  def point; retour @ data [index]; fin
  
end # Window_PartySelect

# ================================================= =============================
# ■ Window_PartyList
# ================================================= =============================

classe Window_PartyList <Window_Selectable
  
  # ------------------------------------------------- -------------------------
  # Initialiser
  # ------------------------------------------------- ------------------------
  def initialize (party_window)
    Super (0, fitting_height (4), window_width, window_height)
    @ Party_window = party_window
    choisir (1)
    désactiver
    Actualiser
  fin
  
  # ------------------------------------------------- -------------------------
  # Window_width
  # ------------------------------------------------- -------------------------
  def window_width; retour 200; fin
  
  # ------------------------------------------------- -------------------------
  # Window_height
  # ------------------------------------------------- -------------------------
  def window_height; revenir Graphics.height - fitting_height (4); fin
  
  # ------------------------------------------------- -------------------------
  # Item_max
  # ------------------------------------------------- -------------------------
  def item_max; retourner @ data? @ Data.size: 1; fin
  
  # ------------------------------------------------- -------------------------
  # Refresh
  # ------------------------------------------------- -------------------------
  def refresh
    make_item_list
    create_contents
    draw_all_items
  fin
  
  # ------------------------------------------------- -------------------------
  # Make_item_list
  # ------------------------------------------------- -------------------------
  def make_item_list
    @ Data = [0]
    pour les membres en $ game_party.all_members
      prochaine si member.nil?
      @ Data.push (member.id)
    fin
    @ Data.push (0)
  fin
  
  # ------------------------------------------------- -------------------------
  # Draw_item
  # ------------------------------------------------- -------------------------
  def draw_item (index)
    clear_item (index)
    rect = item_rect (index)
    si @ data [index] == 0
      draw_remove (rect)
      retour
    fin
    acteur = $ game_actors [@ data [index]]
    draw_actor (acteur, rect)
    draw_actor_locked (acteur, rect)
    draw_actor_required (acteur, rect)
  fin
  
  # ------------------------------------------------- -------------------------
  # Draw_remove
  # ------------------------------------------------- -------------------------
  def draw_remove (rect)
    reset_font_settings
    draw_icon (Icon.remove_party, rect.x +4, rect.y)
    text = YEA :: PARTY :: REMOVE_TEXT
    draw_text (rect.x +32, rect.y, rect.width-32, line_height, texte)
  fin
  
  # ------------------------------------------------- -------------------------
  # Draw_actor
  # ------------------------------------------------- -------------------------
  def draw_actor (acteur, rect)
    buffer = YEA :: PARTY :: ACTOR_Y_BUFFER
    draw_actor_graphic (acteur, rect.x + 16, + rect.y rect.height + tampon)
    text = actor.name
    change_color (list_colour (acteur), permis? (acteur))
    draw_text (rect.x +32, rect.y, rect.width-32, line_height, texte)
  fin
  
  # ------------------------------------------------- -------------------------
  # List_colour
  # ------------------------------------------------- -------------------------
  def list_colour (acteur)
    retourner text_color (YEA :: PARTY :: IN_PARTY_COLOUR) si in_party? (acteur)
    retourner normal_color
  fin
  
  # ------------------------------------------------- -------------------------
  # Draw_actor_locked
  # ------------------------------------------------- -------------------------
  def draw_actor_locked (acteur, rect)
    le retour à moins actor.locked
    draw_icon (Icon.locked_party, rect.width-24, rect.y)
  fin
  
  # ------------------------------------------------- -------------------------
  # Draw_actor_required
  # ------------------------------------------------- -------------------------
  def draw_actor_required (acteur, rect)
    revenir si actor.locked
    le retour à moins actor.required
    draw_icon (Icon.required_party, rect.width-24, rect.y)
  fin
  
  # ------------------------------------------------- -------------------------
  # Permis?
  # ------------------------------------------------- -------------------------
  def activée? (acteur)
    return false si actor.locked
    return false si && actor.required in_party? (acteur)
    retourner actor.exist?
  fin
  
  # ------------------------------------------------- -------------------------
  # In_party?
  # ------------------------------------------------- -------------------------
  def in_party (acteur);? return $ game_party.battle_members.include (acteur);? fin
  
  # ------------------------------------------------- -------------------------
  # Current_item_enabled?
  # ------------------------------------------------- -------------------------
  def current_item_enabled?
    acteur = $ game_actors [Article]
    remplacer = $ game_actors [@ party_window.item]
    sauf actor.nil?
      return false si && actor.locked in_party? (acteur)
      return false si && actor.required in_party? (acteur)
    fin
    return true si replace.nil?
    return false si replace.locked
    return false si replace.required
    return true si actor.nil?
    retourner actor.exist?
  fin
  
  # ------------------------------------------------- -------------------------
  # Item
  # ------------------------------------------------- -------------------------
  def point; retour @ data [index]; fin
  
end # Window_PartyList

# ================================================= =============================
# ** Window_PartyStatus
# ================================================= =============================

classe Window_PartyStatus <Window_Base
  
  # ------------------------------------------------- -------------------------
  # Initialiser
  # ------------------------------------------------- -------------------------
  def initialize (party_window, list_window)
    Super (200, fitting_height (4), window_width, window_height)
    @ Party_window = party_window
    @ List_window = list_window
    @ Acteur = active_actor
    Actualiser
  fin
  
  # ------------------------------------------------- -------------------------
  # Window_width
  # ------------------------------------------------- -------------------------
  def window_width; Graphics.width - 200; fin
  
  # ------------------------------------------------- -------------------------
  # Window_height
  # ------------------------------------------------- -------------------------
  def window_height; Graphics.height - fitting_height (4); fin
  
  # ------------------------------------------------- -------------------------
  # Met à jour
  # ------------------------------------------------- -------------------------
  def update
    Super
    rafraîchissement si @ acteur! = active_actor
  fin
  
  # ------------------------------------------------- -------------------------
  # Active_actor
  # ------------------------------------------------- -------------------------
  def active_actor
    if@list_window.active
      acteur = @ list_window.item
    autre
      acteur = @ party_window.item
    fin
    retourner nulle si [0, nil]. comprendre? (acteur)
    retourner acteur
  fin
  
  # ------------------------------------------------- -------------------------
  # Refresh
  # ------------------------------------------------- -------------------------
  def refresh
    contents.clear
    @ Acteur = active_actor
    reset_font_settings
    if@actor.nil?
      draw_nil_actor
      retour
    fin
    acteur = $ game_actors [@ acteur]
    draw_actor_face (acteur, 0, 0)
    draw_actor_name (acteur, 108, 0)
    draw_actor_class (acteur, 228, 0, contents.width-232)
    draw_actor_level (acteur, 108, line_height)
    draw_actor_icons (acteur, 228, line_height, contents.width-232)
    draw_actor_hp (acteur, 108, line_height * 2, contents.width-112)
    draw_actor_mp (acteur, 108, line_height * 3, contents.width-112)
    draw_actor_parameters (acteur, 0, line_height * 4 + line_height / 2)
    draw_equipments (acteur, contents.width / 2, line_height * 4 + line_height / 2)
  fin
  
  # ------------------------------------------------- -------------------------
  # Draw_nil_actor
  # ------------------------------------------------- -------------------------
  def draw_nil_actor
    color = Color.new (0, 0, 0, translucent_alpha / 2)
    rect = Rect.new (0, 0, contents.width, contents.height)
    contents.fill_rect (rect, couleur)
    change_color (system_color)
    text = YEA :: PARTY :: NO_DATA
    draw_text (rect, texte, 1)
  fin
  
  # ------------------------------------------------- -------------------------
  # Draw_actor_parameters
  # ------------------------------------------------- -------------------------
  def draw_actor_parameters (acteur, dx, dy)
    ps = contents.width / 2 - 4
    rect = Rect.new (dx +1, dy +1, DW - 2, line_height - 2)
    contents.font.size = YEA :: PARTY :: STAT_FONT_SIZE
    color = Color.new (0, 0, 0, translucent_alpha / 2)
    array = [: ATK: def,: mat,: MDF,: agi,: Luk]
    cx = 4
    pour stat dans le tableau
      cas stat
      lorsque: ATK
        param = Vocab :: param (2)
        value = actor.atk.group
      lorsque: def
        param = Vocab :: param (3)
        value = actor.def.group
      lorsque: mat
        param = Vocab :: param (4)
        value = actor.mat.group
      lorsque: MDF
        param = Vocab :: param (5)
        value = actor.mdf.group
      lorsque: AGI
        param = Vocab :: param (6)
        value = actor.agi.group
      lorsque: Luk
        param = Vocab :: param (7)
        value = actor.luk.group
      d'autre; prochaine
      fin
      contents.fill_rect (rect, couleur)
      change_color (system_color)
      draw_text (rect.x + cx, rect.y, rect.width-cx * 2, line_height, param, 0)
      change_color (normal_color)
      draw_text (rect.x + cx, rect.y, rect.width-cx * 2, line_height, la valeur 2)
      rect.y + = line_height
    fin
    reset_font_settings
  fin
  
  # ------------------------------------------------- -------------------------
  # Draw_equipments
  # ------------------------------------------------- -------------------------
  draw_equipments def (acteur, dx, dy)
    text = YEA :: PARTY :: EQUIP_TEXT
    change_color (system_color)
    draw_text (dx, dy, contents.width - dx, line_height, texte, 1)
    dy + = line_height
    si actor.equips.size <= 5
      actor.equips.each_with_index faire | article, je |
        draw_item_name (item, dx, dy + line_height * i)
      fin
    autre
      orig_x = dx
      actor.equips.each_with_index faire | article, je |
        prochaine si item.nil?
        draw_icon (item.icon_index, dx, dy)
        dy + = line_height si dx + 48> contents.width
        dx = dx + 48> contents.width? orig_x: dx + 24
      fin
    fin
  fin
  
end # Window_PartyStatus

# ================================================= =============================
# ■ Scene_Menu
# ================================================= =============================

classe Scene_Menu <Scene_MenuBase
  
  # ------------------------------------------------- -------------------------
  # Écraser méthode: command_formation
  # ------------------------------------------------- -------------------------
  si YEA :: PARTY :: ENABLE_MENU
  def command_formation
    SceneManager.call (Scene_Party)
  fin
  end # YEA :: PARTY :: ENABLE_MENU
  
end # Scene_Menu

# ================================================= =============================
# ■ Scene_Party
# ================================================= =============================

classe Scene_Party <Scene_MenuBase
  
  # ------------------------------------------------- -------------------------
  # Commencer
  # ------------------------------------------------- -------------------------
  def début
    Super
    @ Former_party = $ game_party.battle_members_array.clone
    create_command_window
    create_party_window
    create_list_window
    create_status_window
  fin
  
  # ------------------------------------------------- -------------------------
  # Create_command_window
  # ------------------------------------------------- -------------------------
  def create_command_window
    @ Command_window Window_PartyMenuCommand.new = (0, 0)
    @ Command_window.set_handler (le changement, la méthode (: adjust_members))
    @ Command_window.set_handler (: supprimer, méthode (: adjust_members))
    @ Command_window.set_handler (: revenir, méthode (: revert_party))
    @ Command_window.set_handler (: finition, méthode (: return_scene))
    @ Command_window.set_handler (: annulation, méthode (: return_scene))
  fin
  
  # ------------------------------------------------- -------------------------
  # Create_party_window
  # ------------------------------------------------- -------------------------
  def create_party_window
    @ Party_window Window_PartySelect.new = (@ command_window)
    @ Party_window.set_handler (: ok, méthode (: on_party_ok))
    @ Party_window.set_handler (: annulation, méthode (: on_party_cancel))
    @ Party_window.set_handler (: pageup, méthode (: on_party_pageup))
    @ Party_window.set_handler (: pagedown, méthode (: on_party_pagedown))
  fin
  
  # ------------------------------------------------- -------------------------
  # Create_list_window
  # ------------------------------------------------- -------------------------
  def create_list_window
    @ List_window Window_PartyList.new = (@ party_window)
    @ List_window.set_handler (: ok, méthode (: on_list_ok))
    @ List_window.set_handler (: annulation, méthode (: on_list_cancel))
  fin
  
  # ------------------------------------------------- -------------------------
  # Create_status_window
  # ------------------------------------------------- -------------------------
  def create_status_window
    @ Status_window Window_PartyStatus.new = (@ party_window, @ list_window)
  fin
  
  # ------------------------------------------------- -------------------------
  # Adjust_members
  # ------------------------------------------------- -------------------------
  adjust_members def
    @ Party_window.activate
  fin
  
  # ------------------------------------------------- -------------------------
  # Window_refresh
  # ------------------------------------------------- -------------------------
  def window_refresh
    $ Game_party.rearrange_actors
    @ Command_window.refresh
    @ Party_window.refresh
    @ List_window.refresh
    $ Game_player.refresh
    $ Game_map.need_refresh = true
  fin
  
  # ------------------------------------------------- -------------------------
  # Revert_party
  # ------------------------------------------------- -------------------------
  def revert_party
    @ Command_window.activate
    Game_party.battle_members_array $ = @ former_party.clone
    window_refresh
  fin
  
  # ------------------------------------------------- -------------------------
  # On_party_ok
  # ------------------------------------------------- -------------------------
  def on_party_ok
    case@command_window.current_symbol
    lorsque: changement
      @ List_window.activate
    lorsque: supprimer
      index = @ party_window.index
      acteur = $ game_actors [$ game_party.battle_members_array [index]]
      Sound.play_equip
      $ Game_party.battle_members_array [index] = 0
      window_refresh
      @ Party_window.activate
    fin
  fin
  
  # ------------------------------------------------- -------------------------
  # On_party_cancel
  # ------------------------------------------------- -------------------------
  def on_party_cancel
    @ Command_window.activate
  fin
  
  # ------------------------------------------------- -------------------------
  # On_party_pageup
  # ------------------------------------------------- -------------------------
  def on_party_pageup
    Sound.play_equip
    actor_id1 = @ party_window.item
    actor_id2 = @ party_window.prev_actor.nil? ? 0: @ party_window.prev_actor.id
    max = @ party_window.item_max-1
    index1 = @ party_window.index
    index2 = @ party_window.index == 0? max: index1-1
    $ Game_party.battle_members_array [index1] = actor_id2
    $ Game_party.battle_members_array [index2] = actor_id1
    window_refresh
  fin
  
  # ------------------------------------------------- -------------------------
  # On_party_pagedown
  # ------------------------------------------------- -------------------------
  def on_party_pagedown
    Sound.play_equip
    actor_id1 = @ party_window.item
    actor_id2 = @ party_window.next_actor.nil? ? 0: @ party_window.next_actor.id
    max = @ party_window.item_max-1
    index1 = @ party_window.index
    index2 = @ party_window.index == max? 0: index1 +1
    $ Game_party.battle_members_array [index1] = actor_id2
    $ Game_party.battle_members_array [index2] = actor_id1
    window_refresh
  fin
  
  # ------------------------------------------------- -------------------------
  # On_list_cancel
  # ------------------------------------------------- -------------------------
  def on_list_cancel
    @ Party_window.activate
  fin
  
  # ------------------------------------------------- -------------------------
  # On_list_ok
  # ------------------------------------------------- -------------------------
  def on_list_ok
    Sound.play_equip
    remplacer = $ game_actors [@ party_window.item]
    acteur = $ game_actors [@ list_window.item]
    index1 = @ party_window.index
    actor_id1 = actor.nil? ? 0: actor.id
    si actor.nil?
      $ Game_party.battle_members_array [index1] = 0
      window_refresh
      @ Party_window.activate
      retour
    fin
    actor_id2 = replace.nil? ? 0: replace.id
    if $ game_party.battle_members_array.include? (actor_id1)
      index2 = game_party.battle_members_array.index $ (actor_id1)
      $ Game_party.battle_members_array [index2] = actor_id2
    fin
    $ Game_party.battle_members_array [index1] = actor_id1
    window_refresh
    @ Party_window.activate
  fin
  
end # Scene_Party

# ================================================= =============================
#
# ▼ Fin de fichier
#
# ================================================= =============================








Quand je lance le jeu ça me donne se message:


  Scrip " line10: SyntaxError occurred.


  unenxpected $undefined
  $ Importé = {}si imported.nil $?




Si quelqu'un sais pourquoi c'est comme sa ou s'il a une idée
pour arranger cela, et voudrais bien me le dire,
je lui en serai très reconnaissant.


Dernière édition par daster le Jeu 13 Juin 2013 - 21:21, édité 1 fois
avatar
hashel
Membre

Nombre de messages : 895
Age : 30
Localisation : Belgique
Distinction : Un bonhomme, un vrai ! [Korndor]
Date d'inscription : 16/05/2012
https://www.youtube.com/user/hashel05

Re: [Résolu] Problème avec Party System de Yanfly

le Jeu 13 Juin 2013 - 21:11
Chez moi il fonctionne très bien, à la ligne 10 j'ai ceci :

$imported = {} if $imported.nil?
avatar
dricc
Membre

Nombre de messages : 2756
Localisation : Lille
Distinction : Altruiste - Incarnation de la Patience [Mist']
Date d'inscription : 10/08/2009

Re: [Résolu] Problème avec Party System de Yanfly

le Jeu 13 Juin 2013 - 21:15
ouais alors , traduire un script , ça ne consiste pas à passer le script entier sous google trad Smile

Tu as traduit des lignes de code , là . Reprends le script originel et ne traduit que ce que tu vois à l'écran .
avatar
Rel
Membre

Nombre de messages : 352
Localisation : Le Mans, Sarthes
Distinction : aucune
Date d'inscription : 18/01/2013

Re: [Résolu] Problème avec Party System de Yanfly

le Jeu 13 Juin 2013 - 21:19
OK merci, j'ai trouvé ce qui n'allais pas:
quand j'ai copier le script, il était (automatiquement) traduit par Google,
donc il y avait un problème.

Merci hashel, c'est grâce à toi, que je m'en suis rendu compte.
je ferai plus attention la prochaine fois...
Contenu sponsorisé

Re: [Résolu] Problème avec Party System de Yanfly

Revenir en haut
Permission de ce forum:
Vous ne pouvez pas répondre aux sujets dans ce forum