Bonne soirée, [VX ACE] Demande de script de customisation pour Renommer un perso

Si vous avez une idée de comment faire et vous avez la gentillesse de m'aidez pour allégez mon jeu en évitant de passez
par les événements pour créé avec 1 variable pour 26 valeurs pour les lettres normales et 26 autres pour les majuscules + les symboles et autant de conditions j'ai pas finis...

Alors qu'une custom utiliserai le système de base juste je voudrais enlever le cadre et modifier un peu l'écart si possible entre les lettres pour créer en arrière plan un cadre en événement plus sympathique et plus en adéquation avec le reste au pire je peux supprimer le cadre dans les graphismes du système mais je crains que les lettres ne soit pas assez espacé pour créer des cadres en bois pour chaque. Du coup je me demandais si quelqu'un connaissait un tel script ou pouvait me le faire...

La police de base serait à changer aussi

Et il faudrait que je puisse changer  la position de la namebox.
Ou si vous aviez un script de saisie de texte serait encore mieux

Merci.

Lien vers mon projet en cours...
https://rpgmakervx.1fr1.net/t20411p100-debut-de-mon-projet-jdr-traditionnel#237641
pour saisir le style que je conçois et si vous avez des idées, pour cette partie je suis preneur.

Un petit schéma de ce que tu souhaites obtenir nous sera très utile. Car si c'est une modification du visuel de base existant sans en modifier les fonctionnalités, ça peut être très simple à faire.

Merci ^^ ,

J'ai taffé sur le visuel et Je voudrais un menu apparence qui ressemble à ça, on appuierait sur le portrait et une sélection de portrait serait disponible. J'aimerais aussi imposer un format de portrait pour que les joueurs puisse créer leur avatar à leur goût s'ils le veulent.
je sais j'ai dis qu'il y aurait des cadres mais ce n'est pas plus mal sans... En fait les principaux suffisent en fin de compte.

Un script serait bienvenu je pense même indispensable pour ce menu-ci juste pour les saisie de noms, même s'il est possible de faire sa en event je te dit pas le bordel...

Voilà c'est à peu près ce que j'imagine à quoi sa pourrait ressembler grosso-modo. je voudrais que la box du nom soit aligné au centre de la boxe quand on saisie les caractères.
comme on vois sur le schémas le curseur de sélection de caractère sera custom.

Voyons voir ce qui existe ...

J'ai une reference :
http://rmvxace.wikia.com/wiki/RPG_Maker_VX_Ace_Master_Script_List

On trouve celui-là par exemple:
http://www.rpgmakervxace.net/topic/12619-est-name-input-using-keyboard/
Mais pas de screenshot donc pas moyen de voir à quoi ça ressemble.
un plus détaillé pour création de characters :
http://forums.rpgmakerweb.com/index.php?/topic/1137-kaimonkeys-character-creation-with-races-version-three-released/
ou encore :
http://www.rpgmakercentral.com/topic/4017-actor-creation-system/

Aucun n'est exactement ce qu'il te faut . L'idée ,c'est de trouver une base de départ .

Merci pour ton aide je vais voir si sa peut m'intéresser.
EST - NAME INPUT USING KEYBOARD a l'air très intéressant ça me ferait gagner de la place honnêtement et je pourrais
mettre un résumé des caractéristiques par exemple à la place. ou autre chose je ne sais pas un fanion de pirate à
choisir ou les deux c'est pas plus mal.

Je l'ai testé avec ses dépendances et le fait d'entrer son nom au clavier est très agréable honnêtement.
Juste faut changer le design.

le site :

http://www.rpgmakercentral.com/topic/12619-est-name-input-using-keyboard/

Fonctionne dans cet ordre juste j'espère qu'il n'y aura pas de problème autre que graphique:

http://pastebin.com/raw/ZYZ1w1QM
http://pastebin.com/raw/rD4rQtKP
http://pastebin.com/CRxFwGEP

J'ai compris comment utiliser certains élément mais impossible de change la couleur de font et la taille
de font pose problèmes lors de l'affichage sur la saisie de nom il dépasse du cadre et si,on va trop large la police
est à moitié effacé.
J'aimerais aussi changé le pas de la police je le trouve écarté par rapport à la police l'écart est trop important ou mal placé, comment faire?

Placé dans le Main

Code:

#==============================================================================
# ** Main
#------------------------------------------------------------------------------
#  This processing is executed after module and class definition is finished.
#==============================================================================


#Script police d'Ecriture
#=========================================
#
#  Auteur : Brandobscure modifié par Tibluedream(peu de gloire mais honnêtement, juste un peu de recherche et de jugeote ).
#
#=======================================
#
# Script à placer au dessus du script Main.
# Vous pouvez modifier le script a la ligne :
# 32 pour le Nom de l'écriture
# 43 pour la taille de l'écriture
# 49 si vous voulez mettre l'écriture en gras
# 53 si vous voulez le mettre en italique                                      
#    
#===============================================================
#
#
# Choix de la police d'ecriture pour le jeu.
# Font.default_name = ["papyrus"]
#
# Vous pouvez placer plusieurs police ecriture en cas ou si le pc d'un joueur
# na pas la police demandé. Voici donc le morceau de code à changer.
#-------------------------------------------------
# Font.default_name = ["Rod","nom de la 2em police"]
#---------------------------------------------------
IdVariableOpacite = 0 #Transparence des menus de 0 à 255.

Font.default_name = ["Prince Valiant"] #Police que j'utilise pour mon projet
#donc a vous de changer.

#Taille de l'ecriture de la police.
Font.default_size= 23

#Option pour les polices d'ecriture.
#false=desactivé; true=activé

#Ecriture en gras.
Font.default_bold = true


#Ecriture en italique
Font.default_italic = false

#Ombre: Activé par défaut.
Font.default_shadow = true

Font.default_color = Color.new(150,150,50,255)
Font.default_out_color = Color.new(0,0,0,182)

opacity = 0
back_opacity = 0
#--------------------------------------------------------------------------
#Prog pour la transparence du Windowskin.
#--------------------------------------------------------------------------
class Window_Base < Window
#--------------------------------------------------------------------------
# ? ?????????
#--------------------------------------------------------------------------
alias ancien_initialize initialize
def initialize(x, y, width, height)
ancien_initialize(x, y, width, height)
self.opacity = IdVariableOpacite
self.back_opacity = IdVariableOpacite
self.openness = 255
end
end

rgss_main { SceneManager.run }

D'autre part j'ai deux petits scripts bien sympas que j'ai trouvé, mais j'aimerai ajouter Ascii extend pour qu'ils prennent en compte les accents..

Le code ASCII de base utilisé dans le script ci dessous




source de la recherche de l'encodage ASCII EXTEND :

http://www.theasciicode.com.ar/extended-ascii-code/letter-e-acute-accent-e-acute-lowercase-ascii-code-130.html

et



Voilà la portion de code du 1er script que j'aimerai changer

Code:

$imported = {} if $imported == nil
$imported["CP_KEYBOARD"] = 1.0

module V  ## Checks a virtual key.
  def self.K(key)
    return Ascii::SYM[key]
  end
end

module Ascii  ## Only the keys I bothered to name.  Some have 2 names.
  SYM = { :k0 => 48, :k1 => 49, :k2 => 50, :k3 => 51, :k4 => 52, :k5 => 53,
          :k6 => 54, :k7 => 55, :k8 => 56, :k9 => 57,
          
          :kA => 65, :kB => 66, :kC => 67, :kD => 68, :kE => 69, :kF => 70,
          :kG => 71, :kH => 72, :kI => 73, :kJ => 74, :kK => 75, :kL => 76,
          :kM => 77, :kN => 78, :kO => 79, :kP => 80, :kQ => 81, :kR => 82,
          :kS => 83, :kT => 84, :kU => 85, :kV => 86, :kW => 87, :kX => 88,
          :kY => 89, :kZ => 90,
          
          :kENTER => 13,    :kRETURN => 13,  :kBACKSPACE => 8, :kSPACE => 32,
          :kESCAPE => 27,   :kESC => 27,     :kSHIFT => 16,    :kTAB => 9,
          :kALT => 18,      :kCTRL => 17,    :kDELETE => 46,   :kDEL => 46,
          :kINSERT => 45,   :kINS => 45,     :kPAGEUP => 33,   :kPUP => 33,
          :kPAGEDOWN => 34, :kPDOWN => 34,   :kHOME => 36,     :kEND => 35,
          :kLALT => 164,    :kLCTRL => 162,  :kRALT => 165,    :kRCTRL => 163,
          :kLSHIFT => 160,  :kRSHIFT => 161,
          
          :kLEFT => 37, :kRIGHT => 39, :kUP => 38, :kDOWN => 40,
          
          :kCOLON => 186,     :kAPOSTROPHE => 222, :kQUOTE => 222,
          :kCOMMA => 188,     :kPERIOD => 190,     :kSLASH => 191,
          :kBACKSLASH => 220, :kLEFTBRACE => 219,  :kRIGHTBRACE => 221,
          :kMINUS => 189,     :kUNDERSCORE => 189, :kPLUS => 187,
          :kEQUAL => 187,     :kEQUALS => 187,     :kTILDE => 192,
          
          :kF1 => 112,  :kF2 => 113,  :kF3 => 114, :kF4 => 115, :kF5 => 116,
          :kF6 => 117,  :kF7 => 118,  :kF8 => 119, :kF9 => 120, :kF10 => 121,
          :kF11 => 122, :kF12 => 123,
        }
end


Et voilà la 2ème

Code:

module ESTRIOLE
  module KEYBOARD_PRESS
    KEYBOARDPRESS = {
      :k0 => 48, :k1 => 49, :k2 => 50, :k3 => 51, :k4 => 52, :k5 => 53,
      :k6 => 54, :k7 => 55, :k8 => 56, :k9 => 57,
          
      :kA => 65, :kB => 66, :kC => 67, :kD => 68, :kE => 69, :kF => 70,
      :kG => 71, :kH => 72, :kI => 73, :kJ => 74, :kK => 75, :kL => 76,
      :kM => 77, :kN => 78, :kO => 79, :kP => 80, :kQ => 81, :kR => 82,
      :kS => 83, :kT => 84, :kU => 85, :kV => 86, :kW => 87, :kX => 88,
      :kY => 89, :kZ => 90,
          
      :kCOLON => 186,     :kQUOTE => 222,
      :kCOMMA => 188,     :kPERIOD => 190,     :kSLASH => 191,
      :kBACKSLASH => 220, :kLEFTBRACE => 219,  :kRIGHTBRACE => 221,
      :kMINUS => 189,     :kEQUAL => 187,     :kTILDE => 192,          
    }
  end
end


_Il faut enlever ce flou horrible aussi et si possible les traits en dessous du texte et place la box où il faut...



Finalement je me demande si ça n'aurait pas été plus facile de faire tout en events vu que je suis une buse en RGSS.
Si vous avez de la doc claire qui indique précisément quoi fait quoi à quel endroit c'est situé et leur dépendances se
serait sympas parce je patauge dans la choucroute dans ce foutoir.

J'ai mis à la bonne taille, au bonne endroit, même si à l'entrée du nom le pas, ce n'est pas encore ça... Tant pis...
Mais je voudrai désactiver l'effet flou pour Window_Name edit que j'ai reconfiguré, quel est la commande?

Code:

#==============================================================================
# ** Window_NameEdit
#------------------------------------------------------------------------------
#  This window is used to edit an actor's name on the name input screen.
#==============================================================================

class Window_NameEdit < Window_Base
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader   :name                     # name
  attr_reader   :index                    # cursor position
  attr_reader   :max_char                 # maximum number of characters
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
 

  
  def initialize(actor, max_char)
    x = (Graphics.width - 360) / 2
    y = (Graphics.height - (fitting_height(4) + fitting_height(9) + 8)) / 2
    super(260, 55, 360, fitting_height(4))
    @actor = actor
    @max_char = max_char
    @default_name = @name = actor.name[0, @max_char]
    @index = @name.size
    deactivate
    refresh
  end
  #--------------------------------------------------------------------------
  # * Revert to Default Name
  #--------------------------------------------------------------------------
  def restore_default
    @name = @default_name
    @index = @name.size
    refresh
    return !@name.empty?
  end
  #--------------------------------------------------------------------------
  # * Add Text Character
  #     ch : character to add
  #--------------------------------------------------------------------------
  def add(ch)
    return false if @index >= @max_char
    @name += ch
    @index += 1
    refresh
    return true
  end
  #--------------------------------------------------------------------------
  # * Go Back One Character
  #--------------------------------------------------------------------------
  def back
    return false if @index == 0
    @index -= 1
    @name = @name[0, @index]
    refresh
    return true
  end
   #--------------------------------------------------------------------------
  # * Get Width of Face Graphic
  #--------------------------------------------------------------------------
  def face_width
    return 96
  end
  #--------------------------------------------------------------------------
  # * Get Character Width
  #--------------------------------------------------------------------------
  def char_width
    text_size($game_system.japanese? ? "あ" : "A").width
  end
  #--------------------------------------------------------------------------
  # * Get Coordinates of Left Side for Drawing Name
  #--------------------------------------------------------------------------
  def left
    name_center = (contents_width + face_width) / 2
    name_width = (@max_char + 1) * char_width
    return [name_center - name_width / 2, contents_width - name_width].min
  end
  #--------------------------------------------------------------------------
  # * Get Rectangle for Displaying Item
  #--------------------------------------------------------------------------
  #--------------------------------------------------------------------------
  #def item_rect(index)
  #  Rect.new(left + index * char_width, 36, char_width, line_height)
  #end
  #--------------------------------------------------------------------------
  
  def item_rect(index)
    Rect.new(left + index * 17, 36, 35, 45)
  end

  #--------------------------------------------------------------------------
  # * Draw Text
  #--------------------------------------------------------------------------
  def draw_char(index)
    rect = item_rect(index)
    rect.x -= 1
    rect.width += 4
    change_color(normal_color)
    draw_text(rect, @name[index] || "")
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    contents.clear
    
    @name.size.times {|i| draw_char(i) }
    cursor_rect.set(item_rect(@index))
  end
end


Trouvé

Je vais vous apprendre de mon experience actuelle comment désactiver complètement
le flou et le changement de ton de l'écran quand on passe à un menu quel qu'il soit venant
du système rpg maker VX Ace

Aller dans Scene_MenuBase

trouvez cette ligne
normalement la ligne 29 sectionCreate Snapshot to Use as Background
commenter la ligne "sélectionnez et (cntrl Q)"

#~     @background_sprite.color.set(16, 16, 16, 128)

ensuite aller dans SceneManager section Create Background ligne 86 normalement
et commentez la

#~     @background_bitmap.blur



Maintenant faudrait faire apparaître un texte en parallèle à la confirmation du nom qui remplacera le nom entré
par le nom sortie tant qu'on est sur cette map et réapparaîtra à chaque fois qu'on y reviendra.
Il y a pas quelqu'un qui peut me filer une piste, s'il vous plait?

J'ai trouvé comment faire pour récupéré le nom de l'acteur et l'affiché en texte
Grâce à ce tuto que j'ai du m'y reprendre à plusieurs fois pour trouver ce que je voulais
http://www.biloucorp.com/afficher-et-manipuler-du-texte-dans-rpg-maker--36

Ensuite j'ai eu juste à ajouter ça dans l'appel de script.

text_show(1, "#{$game_actors[1].name}" , get_profile(:profilA), 300, 105)
Ensuite je prend l'id utilisé ici 1 en 1ère argument et j'utilise sur un autre appel de script
text_erase(1)
pour l'effacer quand je l'ai décidé ^^.
Je vais finir par me débrouiller finalement en script, enfin un peu...

Au fait vous n'auriez pas une idée de comment récupérer le nombre de caractère du nom puis
le calculer par rapport à la taille du nom et le divisé en deux puis définir son origine x à partir de ce point?

J'ai trouvé la moitié de la solution ^^ pour le texte centrer automatiquement quelque soit le nom quand on a sélectionne sa fonctionne j'ai dut modifié quelque peu le script original pour mais bon après des heure de testes c'est passé mais il manque encore le centrage auto lors de l'écriture là sa se complique je pense.

le bout de code que j'ai changé pour centré le texte au milieu de son épicentre

 # * Update Position
 #--------------------------------------------------------------------------
 def update_position
   self.x = @text.x - bitmap.width / 2.5
   self.y = @text.y
   self.z = @text.number
 end

Ne me demandez pas pourquoi 2.5 et pas 2 comme je l'avais prévus au début il doit y
avoir un paramètre qui m'est encore inconnue où sa doit dépasser un peu de la taille du texte
du coup dans l'appel de script j'ai pu mettre la première lettre au milieu de mon cadre

text_show(1, "#{$game_actors[1].name}" , get_profile(:profilA), 400, 105)

Désolé de ne pas pouvoir t'aider plus mais je n'ai plus VXAce .

J'espere que quelqu'un d'autre pourra t'aider .

Merci je vais finir par trouver à force de fouiller si personnes n'a la réponse ^^

Pour récupérer la longueur, je croit que c'est $game_actors[1].name.length
Donc c'est du calcul :
number = $game_actors[1].name.length / 2

Donc la variable récupère la longueur et divise par 2.

Je ne pense pas que se soit ça qu'il me faut car là le nom n'est pas encore entré l'information n'est pas encore passé la variable n'as pas reçut la valeur du coup je pense que faut atteindre direct la variable char pour faire +1 à une variable dès que l'on entre un input lors de l'activation. Enfin je pense... faut voir si j'arrive à placer ton petit code mais je ne suis pas sûr que sa fonctionne je n'ai pas vu de .length sur la class en plus. Juste .width

En fait j'ai l'impression que   def initialize(actor, max_char) n'est en fonction qu'une seul fois et n'est pas rafraîchis avant un autre nom entré
que la gestion de position ne se fait pas en boucle.

Oui c'est bien sa le problème def initialize(actor, max_char) ne se lance qu'une fois et le reste du scripte fais l'oeuvre c'est parfait pour économiser du temps procédural et de la ressource mais moi ça ne m'arrange pas qu'il n'y est pas de refresh pour la position, il y a tellement de fonction dans tous les scripts que je m'y perd en plus. surtout sur l’interpréter qui n'est pas très explicite sur ce qu'il est possible de faire avec cette config...

punaise j'ai tenté de gruger avec ce petit code

def update_position
   initialize(@actor, @max_char)
end

mais sa me fait planter mon jeux faut que je mette sans doute une limitation sinon il le fera infiniment


Je viens de me rendre compte que mon 1er code rencontre un problème lorsque je supprime le texte de la scène
pas un petit avis sur la question? Je ne suis pas à l'aise avec les scripts,
un coup de main serait pas de refus mon cerveau fume.

"___________________________________________"
Script 'Display_Text' line455: NoMethodError occured
undefined method 'width' for nil:NilClass
"___________________________________________"


(j'ai essayé ton code pour remplacé celui que j'avais mais sa ne semble pas avoir d'effet sur le jeu du coup
mais si tu m'expliquais je comprendrais peut être.) Merci d'ailleurs même si j'ai pas trouvé c'est sympas. ^^

Code:

# Affichage facile de texte
# Dépend de https://github.com/nukiFW/RPGMaker/tree/master/StandardizeRGSS
# Documentation : https://github.com/nukiFW/RPGMaker/tree/master/DisplayText
#==============================================================================
# ** TextProfile
#------------------------------------------------------------------------------
#  Représente un profil de mise en forme du texte
#==============================================================================

class TextProfile
  #--------------------------------------------------------------------------
  # * Singleton de TextProfile
  #--------------------------------------------------------------------------
  class << self
    #--------------------------------------------------------------------------
    # * Profils enrigistrés
    #--------------------------------------------------------------------------
    attr_accessor :registered
    TextProfile.registered ||= Hash.new
  end
  #--------------------------------------------------------------------------
  # * Variables d'instances
  #--------------------------------------------------------------------------
  attr_accessor :size
  attr_accessor :font
  attr_accessor :color
  attr_accessor :italic
  attr_accessor :bold
  attr_accessor :outline
  attr_accessor :outline_color
  attr_accessor :shadow
  attr_accessor :multiline
  #--------------------------------------------------------------------------
  # * Constructeur
  #--------------------------------------------------------------------------
  def initialize(*profile)
    if profile.length > 0
      val             = profile[0]
      @size           = val.size
      @font           = val.font
      @color          = val.color
      @italic         = val.italic
      @bold           = val.bold
      @outline        = val.outline
      @outline_color  = val.outline_color
      @shadow         = val.shadow
      @multiline      =val.multiline
    else
      @size           = Font.default_size
      @font           = Font.default_name
      @color          = Font.default_color
      @italic         = Font.default_italic
      @bold           = Font.default_bold
      @outline        = Font.default_outline
      @outline_color  = Font.default_out_color
      @shadow         = Font.default_shadow
      @multiline      = false
    end
  end
  #--------------------------------------------------------------------------
  # * Sauvegarde un profile
  #--------------------------------------------------------------------------
  def register(name)
    TextProfile.registered[name.to_sym] = self
  end
  #--------------------------------------------------------------------------
  # * Convertit en objet font
  #--------------------------------------------------------------------------
  def to_font
    f = Font.new
    f.name        = @font
    f.size        = @size
    f.bold        = @bold
    f.italic      = @italic
    f.outline     = @outline
    f.shadow      = @shadow
    f.color       = @color
    f.out_color   = @outline_color
    return f
  end
end

#==============================================================================
# ** Color
#------------------------------------------------------------------------------
#  Représente une couleur
#==============================================================================

class Color
  #--------------------------------------------------------------------------
  # * Singleton de Color
  #--------------------------------------------------------------------------
  class << self
    #--------------------------------------------------------------------------
    # * Couleurs enrigistrés
    #--------------------------------------------------------------------------
    attr_accessor :registered
    Color.registered ||= Hash.new
  end
  #--------------------------------------------------------------------------
  # * Sauvegarde un profile
  #--------------------------------------------------------------------------
  def register(name)
    Color.registered[name.to_sym] = self
  end
end

#==============================================================================
# ** Kernel
#------------------------------------------------------------------------------
#  Ajout des méthodes de manipulation de profile et de couleurs
#==============================================================================

module Kernel
  #--------------------------------------------------------------------------
  # * Récupération d'un TextProfile
  #--------------------------------------------------------------------------
  def get_profile(name)
    TextProfile.registered[name.to_sym] || TextProfile.registered[:default]
  end
  #--------------------------------------------------------------------------
  # * Récupération d'une couleur
  #--------------------------------------------------------------------------
  def get_color(name)
    Color.registered[name.to_sym] || Color.new(255,255,255)
  end
  #--------------------------------------------------------------------------
  # * Création d'un profil
  #--------------------------------------------------------------------------
  def create_profile(*args)
    TextProfile.new(*args)
  end
  #--------------------------------------------------------------------------
  # * Création d'une couleur
  #--------------------------------------------------------------------------
  def create_color(*args)
    Color.new(*args)
  end
end

#==============================================================================
# ** Game_Text
#------------------------------------------------------------------------------
#  Représentation d'un texte dynamiquement
#==============================================================================

class Game_Text
  #--------------------------------------------------------------------------
  # * Variables d'instances
  #--------------------------------------------------------------------------
  attr_reader :number
  attr_reader :origin
  attr_reader :x, :y
  attr_reader :zoom_x, :zoom_y
  attr_reader :opacity
  attr_reader :angle
  attr_reader :blend_type
  attr_accessor :text_value
  attr_accessor :profile
  #--------------------------------------------------------------------------
  # * Constructeur
  #--------------------------------------------------------------------------
  def initialize(index)
    @profile = nil
    @number = index
    init_basic
    init_target
    init_rotate
  end
  #--------------------------------------------------------------------------
  # * Initialise les variables basiques
  #--------------------------------------------------------------------------
  def init_basic
    @text_value = ""
    @origin = @x = @y = 0
    @zoom_x = @zoom_y = 100.0
    @opacity = 255.0
    @blend_type = 1
  end
  #--------------------------------------------------------------------------
  # * Initialise le mouvement
  #--------------------------------------------------------------------------
  def init_target
    @target_x = @x
    @target_y = @y
    @target_zoom_x = @zoom_x
    @target_zoom_y = @zoom_y
    @target_opacity = @opacity
    @duration = 0
  end
  #--------------------------------------------------------------------------
  # * Initialise la Rotation
  #--------------------------------------------------------------------------
  def init_rotate
    @angle = 0
    @rotate_speed = 0
  end
  #--------------------------------------------------------------------------
  # * Affiche un texte à l'écran
  #--------------------------------------------------------------------------
  def show(text_value, profile, x, y, z_x = 100, z_y = 100, op = 255, bt = 0, ori = 0)
    @profile = profile
    @text_value = text_value.to_s
    @origin = ori
    @x = x.to_f
    @y = y.to_f
    @zoom_x = z_x.to_f
    @zoom_y = z_y.to_f
    @opacity = op.to_f
    @blend_type = bt
    init_target
    init_rotate
  end
  #--------------------------------------------------------------------------
  # * Déplacement du texte
  #--------------------------------------------------------------------------
  def move(duration, x = -1, y = -1, zoom_x = -1, zoom_y = -1, opacity = -1, blend_type = -1, origin = -1)
    @origin = origin unless origin == -1
    @target_x = x.to_f unless x == -1
    @target_y = y.to_f unless y == -1
    @target_zoom_x = zoom_x.to_f unless zoom_x == -1
    @target_zoom_y = zoom_y.to_f unless zoom_y == -1
    @target_opacity = opacity.to_f unless opacity == -1
    @blend_type = blend_type unless blend_type == -1
    @duration = duration
  end
  #--------------------------------------------------------------------------
  # * Change la rotation
  #--------------------------------------------------------------------------
  def rotate(speed)
    @rotate_speed = speed
  end
  #--------------------------------------------------------------------------
  # * Erase Picture
  #--------------------------------------------------------------------------
  def erase
    @text_value = ""
    @profile = nil
    @origin = 0
  end
  #--------------------------------------------------------------------------
  # * Modification a chaque frame
  #--------------------------------------------------------------------------
  def update
    update_move
    update_rotate
  end
  #--------------------------------------------------------------------------
  # * Modification du mouvement
  #--------------------------------------------------------------------------
  def update_move
    return if @duration == 0
    d = @duration
    @x = (@x * (d - 1) + @target_x) / d
    @y = (@y * (d - 1) + @target_y) / d
    @zoom_x  = (@zoom_x  * (d - 1) + @target_zoom_x)  / d
    @zoom_y  = (@zoom_y  * (d - 1) + @target_zoom_y)  / d
    @opacity = (@opacity * (d - 1) + @target_opacity) / d
    @duration -= 1
  end
  #--------------------------------------------------------------------------
  # * Modification de la rotation
  #--------------------------------------------------------------------------
  def update_rotate
    return if @rotate_speed == 0
    @angle += @rotate_speed / 2.0
    @angle += 360 while @angle < 0
    @angle %= 360
  end
end

#==============================================================================
# ** Game_Texts
#------------------------------------------------------------------------------
#  Représente la collection de textes
#==============================================================================

class Game_Texts
  #--------------------------------------------------------------------------
  # * Construction
  #--------------------------------------------------------------------------
  def initialize
    @data = []
  end
  #--------------------------------------------------------------------------
  # * Renvoi un text
  #--------------------------------------------------------------------------
  def [](number)
    @data[number] ||= Game_Text.new(number)
  end
  #--------------------------------------------------------------------------
  # * Iterator
  #--------------------------------------------------------------------------
  def each
    @data.compact.each {|text| yield text } if block_given?
  end
end

#==============================================================================
# ** Game_Screen
#------------------------------------------------------------------------------
#  Ajoute la gestion du texte
#==============================================================================

class Game_Screen
  #--------------------------------------------------------------------------
  # * Variables d'instances
  #--------------------------------------------------------------------------
  attr_reader :texts
  #--------------------------------------------------------------------------
  # * Alias
  #--------------------------------------------------------------------------
  alias :displaytext_initialize :initialize
  alias :displaytext_update     :update
  #--------------------------------------------------------------------------
  # * Construction
  #--------------------------------------------------------------------------
  def initialize
    @texts = Game_Texts.new
    displaytext_initialize
  end
  #--------------------------------------------------------------------------
  # * Nettoyage de l'écran
  #--------------------------------------------------------------------------
  if !RPGMAKER.xp?
    alias :displaytext_clear :clear
    def clear
      displaytext_clear
      clear_texts
    end
  end
  #--------------------------------------------------------------------------
  # * Nettoyage des textes
  #--------------------------------------------------------------------------
  def clear_texts
    @texts.each{|t|t.erase}
  end
  #--------------------------------------------------------------------------
  # * Modification a chaque frame
  #--------------------------------------------------------------------------
  def update
    displaytext_update
    update_texts
  end
  #--------------------------------------------------------------------------
  # * Modification des textes
  #--------------------------------------------------------------------------
  def update_texts
    @texts.each{|t|t.update}
  end
end


#==============================================================================
# ** Sprite_Text
#------------------------------------------------------------------------------
#  Représente la vue du texte
#==============================================================================

class Sprite_Text < Sprite
  #--------------------------------------------------------------------------
  # * Construction de l'objet
  #--------------------------------------------------------------------------
  def initialize(viewport, dynamic_text)
    super(viewport)
    @text = dynamic_text
    @text_value = ""
    @profile = nil
  end
  #--------------------------------------------------------------------------
  # * Libération
  #--------------------------------------------------------------------------
  def dispose
    bitmap.dispose if bitmap
    super
  end
  #--------------------------------------------------------------------------
  # * Modification à chaque frames
  #--------------------------------------------------------------------------
  def update
    super
    update_bitmap
    update_origin
    update_position
    update_zoom
    update_other
  end
  #--------------------------------------------------------------------------
  # * Création du bitmap
  #--------------------------------------------------------------------------
  def create_bitmap
    font = @text.profile.to_font
    bmp = Bitmap.new(1,1)
    bmp.font = font
    unless @text.profile.multiline
      rect = bmp.text_size(@text_value)
      self.bitmap = Bitmap.new(rect.width+32, rect.height)
      self.bitmap.font = font
      self.bitmap.draw_text(0, 0, rect.width+32, rect.height, @text_value, 0)
    else
      # Création d'une boite multiligne
      lines = @text_value.split("\n")
      widths = Array.new
      heights = Array.new
      lines.each do |line|
        r = bmp.text_size(line)
        widths << r.width
        heights << r.height
      end
      width, height = widths.max, heights.max
      total_height = height * lines.length
      self.bitmap = Bitmap.new(width+32, total_height)
      self.bitmap.font = font
      iterator = 0
      lines.each do |line|
        self.bitmap.draw_text(0, iterator, width+32, height, line, 0)
        iterator += height
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Modification du transfert de l'image
  #--------------------------------------------------------------------------
  def update_bitmap
    if @text.text_value.empty?
      self.bitmap = nil
      @text_value = ""
    else
      if @text.text_value != @text_value || @profile != @text.profile
        @profile = @text.profile
        @text_value = @text.text_value
        if self.bitmap && !self.bitmap.disposed?
          self.bitmap = nil
        end
        create_bitmap
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Modification de l'origine
  #--------------------------------------------------------------------------
  def update_origin
    if @text.origin == 0
      self.ox = 0
      self.oy = 0
    else
      self.ox = bitmap.width / 2
      self.oy = bitmap.height / 2
    end
  end
  #--------------------------------------------------------------------------
  # * Update Position
  #--------------------------------------------------------------------------
  def update_position
    self.x = @text.x - bitmap.width / 2.5 #Erreur se montre parfois
    self.y = @text.y
    self.z = @text.number
  end
  #--------------------------------------------------------------------------
  # * Update Zoom Factor
  #--------------------------------------------------------------------------
  def update_zoom
    self.zoom_x = @text.zoom_x / 100.0
    self.zoom_y = @text.zoom_y / 100.0
  end
  #--------------------------------------------------------------------------
  # * Update Other
  #--------------------------------------------------------------------------
  def update_other
    self.opacity = @text.opacity
    self.blend_type = @text.blend_type
    self.angle = @text.angle
  end
end

#==============================================================================
# ** Spriteset_Map
#------------------------------------------------------------------------------
#  Ajout de la vue des textes
#==============================================================================

class Spriteset_Map
  #--------------------------------------------------------------------------
  # * Alias
  #--------------------------------------------------------------------------
  alias :displaytext_initialize :initialize
  alias :displaytext_dispose    :dispose
  alias :displaytext_update     :update
  #--------------------------------------------------------------------------
  # * Construction
  #--------------------------------------------------------------------------
  def initialize
    create_texts
    displaytext_initialize
  end
  #--------------------------------------------------------------------------
  # * Création des texts vierges
  #--------------------------------------------------------------------------
  def create_texts
    @text_sprites = Array.new
  end
  #--------------------------------------------------------------------------
  # * Libération
  #--------------------------------------------------------------------------
  def dispose
    displaytext_dispose
    dispose_texts
  end
  #--------------------------------------------------------------------------
  # * Libération des textes
  #--------------------------------------------------------------------------
  def dispose_texts
    @text_sprites.compact.each {|t| t.dispose }
  end
  #--------------------------------------------------------------------------
  # * Modification a chaque frame
  #--------------------------------------------------------------------------
  def update
    update_texts
    displaytext_update
  end
  #--------------------------------------------------------------------------
  # * Modification des texts
  #--------------------------------------------------------------------------
  def update_texts
    RGSS.screen.texts.each do |txt|
      @text_sprites[txt.number] ||= Sprite_Text.new(@viewport2, txt)
      @text_sprites[txt.number].update
    end
  end
end

#==============================================================================
# ** Game_Interpreter
#------------------------------------------------------------------------------
#  Ajout de l'API de manipulation des textes
#==============================================================================

class Game_Interpreter
  #--------------------------------------------------------------------------
  # * Affiche un text
  #--------------------------------------------------------------------------
  def text_show(id, *args)
    RGSS.screen.texts[id].show(*args)
  end
  #--------------------------------------------------------------------------
  # * Déplace un texte
  #--------------------------------------------------------------------------
  def text_move(id, duration, wait_flag, x = -1, y = -1, zoom_x = -1,
      zoom_y = -1, opacity = -1, blend_type = -1, origin = -1)
    RGSS.screen.texts[id].move(
      duration, x, y, zoom_x, zoom_y, opacity,
      blend_type, origin
    )
    if wait_flag
      wait(duration) if RPGMAKER.vxace?
      @wait_count = duration if RPGMAKER.vx?
    end
  end
  #--------------------------------------------------------------------------
  # * Supprime un texte
  #--------------------------------------------------------------------------
  def text_erase(id)
    RGSS.screen.texts[id].erase
  end
  #--------------------------------------------------------------------------
  # * Change un texte
  #--------------------------------------------------------------------------
  def text_change(id, value)
    RGSS.screen.texts[id].text_value = value
  end
  #--------------------------------------------------------------------------
  # * Change un profile
  #--------------------------------------------------------------------------
  def text_change_profile(id, profile)
    RGSS.screen.texts[id].profile = profile
  end
  #--------------------------------------------------------------------------
  # * Rotation
  #--------------------------------------------------------------------------
  def text_rotate(id, speed)
    RGSS.screen.texts[id].rotate(speed)
  end
  #--------------------------------------------------------------------------
  # * Change l'opacité
  #--------------------------------------------------------------------------
  def text_opacity(id, value)
    RGSS.screen.texts[id].opacity = value
  end
end

#--------------------------------------------------------------------------
# * Enregistrement du profile par défaut
#--------------------------------------------------------------------------
create_profile.register(:default)
#--------------------------------------------------------------------------
# * Enregistrement de couleurs par défaut
#--------------------------------------------------------------------------
create_color(255,255,255).register(:white)
create_color(255,0,0).register(:red)
create_color(0,255,0).register(:green)
create_color(0,0,255).register(:blue)
create_color(0,0,0).register(:black)

J'ai changé de stratégie j'ai modifier l'origine directement et sa fonctionne

 def update_origin
   if @text.origin == 0
     self.ox = 0
     self.oy = 0
   else
     self.ox = bitmap.width / 2.5
     self.oy = bitmap.height #/ 2
   end
 end

Bug mineur trouvé, si boite de message non utilisé message d'erreur

je viens de tomber sur un problème je me demandais d'où il venait l'écran se figeait lorsque j'appuyait sur haut et sur bas ça fonctionnait correctement alors que le code était exactement le même dans les deux cas la seul chose qui changeait c'est qu'il était actif sur deux page distinct avec le même code mais pas la même variable local c'était à me rendre fou. Le code devait fonctionner, en revanche ce que je n'avait pas vu c'est que le type de déclencheur ça il était différent le premier truc qu'on oublie de vérifier ^^|||, il était en automatique... alors à savoir si deux événements sont auto en même temps ça plante le jeu. Du coup j'l'ai changé pour parallèles et sa remarche impec... -_- hehe!

j'optimise le fonctionnement en réduisant les temps d'attente des fondu qui sont juste avant les echap du coup on mettait 3 plombe pour le faire fonctionner au début je comprenais pas pourquoi fallait attendre aussi longtemps avant que la touche soit reconnu après je suis souvenu du problème de fondu ^^.

Des fois découper en plusieurs événements ça augmente la rapidité d’exécution du temps de calcul c'est appréciable ^^ j'ai enfin réussi à optimiser le temps de réaction des input ^^