- RelMembre
- 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
Jeu 13 Juin 2013 - 21:08
Voila j'ai un problème avec le script de Yanfly: Party System
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.
- 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.
Re: [Résolu] Problème avec Party System de Yanfly
Jeu 13 Juin 2013 - 21:11
Chez moi il fonctionne très bien, à la ligne 10 j'ai ceci :
$imported = {} if $imported.nil?
$imported = {} if $imported.nil?
- driccMembre
- Nombre de messages : 2760
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
Jeu 13 Juin 2013 - 21:15
ouais alors , traduire un script , ça ne consiste pas à passer le script entier sous google trad
Tu as traduit des lignes de code , là . Reprends le script originel et ne traduit que ce que tu vois à l'écran .
Tu as traduit des lignes de code , là . Reprends le script originel et ne traduit que ce que tu vois à l'écran .
- RelMembre
- 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
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...
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...
- [résolu]problème correspondance Icone script Ace Battle Engine Yanfly
- Problème avec le script Ace Core Engine Traduit par UltimaSasuke et réaliser par Yanfly [Résolu]
- [résolu]Behind view battle system(Jet sideview) problème
- Probleme avec le Side batlle system tankantei[résolu]
- [Résolu]Probleme entre KGC Large Party et Tankentai
Permission de ce forum:
Vous ne pouvez pas répondre aux sujets dans ce forum
|
|