Partagez
Aller en bas
avatar
Elbric
Membre

Nombre de messages : 58
Age : 24
Distinction : aucune
Date d'inscription : 06/03/2013

Résolu [Résolu] Changer les touches directionnelles de base

le Ven 1 Nov 2013 - 12:27
Bonjour à tous,

J'aimerais changer les touches directionnelles de base pour pouvoir jouer en ZQSD. Seulement j'aimerais que le joueur n'ai pas à changer ses touches en allant dans le menu F1... En fait j'aimerais que le mode ZQSD soit disponible de base.
J'ai fait des recherches mais je n'ai rien trouvé :/

Merci pour votre future aide ! Smile


Dernière édition par Elbric le Sam 2 Nov 2013 - 18:35, édité 3 fois
avatar
Zarby
Membre

Nombre de messages : 71
Age : 29
Distinction : aucune
Date d'inscription : 15/12/2011

Résolu Re: [Résolu] Changer les touches directionnelles de base

le Ven 1 Nov 2013 - 13:28
trouvé en moin de 1 minute Smile
sauf que avec ce script pour ceux qui on un clavier qwerty ca va pas évident de jouer a ton jeu :o
tu peut changer tout les touche dans la configuration du script plus bas en changant les lignes :
UP = [KEYMAP[:UP]]

par

UP = [KEYMAP[:LETTER_Z]]

j'ai déja placé pour zqsd
Code:

#==============================================================================

# ** Input

#------------------------------------------------------------------------------

# Created By Cidiomar R. Dias Junior

# Originally posted at http://rgss3help.tk/?p=145

#

# Terms of Use: http://rgss3help.tk/?page_id=159

#------------------------------------------------------------------------------

# A module that handles input data from a gamepad or keyboard.

# Managed by symbols rather than button numbers in RGSS3.

#==============================================================================



module Input  

 #--------------------------------------------------------------------------

 # * Keymap in symbols

 # To get a key from the keymap, you can use Input.key(sym) or Input:KEYMAP[sym]

 # Or if you want to use a symbol in a input function, just pass the symbol

 # as argument.

 #--------------------------------------------------------------------------

 KEYMAP = {

       LBUTTON:                          0x01,  RBUTTON:                         0x02,

       CANCEL:                    0x03,  MBUTTON:                        0x04,

       XBUTTON1:                        0x05,  XBUTTON2:                        0x06,

       BACK:                            0x08,  TAB:                              0x09,

       CLEAR:                          0x0c,  RETURN:                     0x0d,

       SHIFT:                          0x10,  CONTROL:                   0x11,

       MENU:                            0x12,  PAUSE:                          0x13,

       CAPITAL:                          0x14,  KANA:                           0x15,

       KANA:                            0x15,  KANA:                            0x15,

       JUNJA:                          0x17,  FINAL:                           0x18,

       HANJA:                          0x19,  HANJA:                           0x19,

       ESCAPE:                    0x1b,  CONVERT:                        0x1c,

       NONCONVERT:                0x1d,  ACCEPT:                          0x1e,

       MODECHANGE:                0x1f,  SPACE:                                0x20,

       PRIOR:                          0x21,  NEXT:                             0x22,

       END:                              0x23,  HOME:                           0x24,

       LEFT:                            0x25,  UP:                                0x26,

       RIGHT:                          0x27,  DOWN:                             0x28,

       SELECT:                    0x29,  PRINT:                                0x2a,

       EXECUTE:                          0x2b,  SNAPSHOT:                       0x2c,

       INSERT:                    0x2d,  DELETE:                          0x2e,

       HELP:                            0x2f,  N0:                                0x30,

       KEY_1:                          0x31,  KEY_2:                           0x32,

       KEY_3:                          0x33,  KEY_4:                           0x34,

       KEY_5:                          0x35,  KEY_6:                           0x36,

       KEY_7:                          0x37,  KEY_8:                           0x38,

       KEY_9:                          0x39,  colon:                           0x3a,

       semicolon:                      0x3b,  less:                             0x3c,

       equal:                          0x3d,  greater:                   0x3e,

       question:                        0x3f,  at:                                0x40,

       LETTER_A:                        0x41,  LETTER_B:                        0x42,

       LETTER_C:                        0x43,  LETTER_D:                        0x44,

       LETTER_E:                        0x45,  LETTER_F:                        0x46,

       LETTER_G:                        0x47,  LETTER_H:                        0x48,

       LETTER_I:                        0x49,  LETTER_J:                        0x4a,

       LETTER_K:                        0x4b,  LETTER_L:                        0x4c,

       LETTER_M:                        0x4d,  LETTER_N:                        0x4e,

       LETTER_O:                        0x4f,  LETTER_P:                        0x50,

       LETTER_Q:                        0x51,  LETTER_R:                        0x52,

       LETTER_S:                        0x53,  LETTER_T:                        0x54,

       LETTER_U:                        0x55,  LETTER_V:                        0x56,

       LETTER_W:                        0x57,  LETTER_X:                        0x58,

       LETTER_Y:                        0x59,  LETTER_Z:                        0x5a,

       LWIN:                            0x5b,  RWIN:                            0x5c,

       APPS:                            0x5d,  asciicircum:              0x5e,

       SLEEP:                          0x5f,  NUMPAD0:                   0x60,

       NUMPAD1:                          0x61,  NUMPAD2:                         0x62,

       NUMPAD3:                          0x63,  NUMPAD4:                         0x64,

       NUMPAD5:                          0x65,  NUMPAD6:                         0x66,

       NUMPAD7:                          0x67,  NUMPAD8:                         0x68,

       NUMPAD9:                          0x69,  MULTIPLY:                       0x6a,

       ADD:                              0x6b,  SEPARATOR:                     0x6c,

       SUBTRACT:                        0x6d,  DECIMAL:                          0x6e,

       DIVIDE:                    0x6f,  F1:                              0x70,

       F2:                                0x71,  F3:                              0x72,

       F4:                                0x73,  F5:                              0x74,

       F6:                                0x75,  F7:                              0x76,

       F8:                                0x77,  F9:                              0x78,

       F10:                              0x79,  F11:                             0x7a,

       F12:                              0x7b,  F13:                             0x7c,

       F14:                              0x7d,  F15:                             0x7e,

       F16:                              0x7f,  F17:                             0x80,

       F18:                              0x81,  F19:                             0x82,

       F20:                              0x83,  F21:                             0x84,

       F22:                              0x85,  F23:                             0x86,

       F24:                              0x87,  NUMLOCK:                         0x90,

       SCROLL:                    0x91,  LSHIFT:                          0xa0,

       RSHIFT:                    0xa1,  LCONTROL:                      0xa2,

       RCONTROL:                        0xa3,  LMENU:                          0xa4,

       RMENU:                          0xa5,  BROWSER_BACK:             0xa6,

       BROWSER_FORWARD:          0xa7,  BROWSER_REFRESH:         0xa8,

       BROWSER_STOP:            0xa9,  BROWSER_SEARCH:    0xaa,

       BROWSER_FAVORITES:      0xab,  BROWSER_HOME:             0xac,

       VOLUME_MUTE:              0xad,  VOLUME_DOWN:             0xae,

       VOLUME_UP:                      0xaf,  MEDIA_NEXT_TRACK:         0xb0,

       MEDIA_PREV_TRACK:        0xb1,  MEDIA_STOP:                0xb2,

       MEDIA_PLAY_PAUSE:        0xb3,  LAUNCH_MAIL:              0xb4,

       LAUNCH_MEDIA_SELECT:  0xb5,  LAUNCH_APP1:                 0xb6,

       LAUNCH_APP2:              0xb7,  cedilla:                         0xb8,

       onesuperior:              0xb9,  masculine:                     0xba,

       guillemotright:    0xbb,  onequarter:              0xbc,

       onehalf:                          0xbd,  threequarters:         0xbe,

       questiondown:            0xbf,  Agrave:                    0xc0,

       Aacute:                    0xc1,  Acircumflex:            0xc2,

       Atilde:                    0xc3,  Adiaeresis:              0xc4,

       Aring:                          0xc5,  AE:                                 0xc6,

       Ccedilla:                        0xc7,  Egrave:                    0xc8,

       Eacute:                    0xc9,  Ecircumflex:            0xca,

       Ediaeresis:                0xcb,  Igrave:                          0xcc,

       Iacute:                    0xcd,  Icircumflex:            0xce,

       Idiaeresis:                0xcf,  ETH:                            0xd0,

       Ntilde:                    0xd1,  Ograve:                          0xd2,

       Oacute:                    0xd3,  Ocircumflex:            0xd4,

       Otilde:                    0xd5,  Odiaeresis:              0xd6,

       multiply:                        0xd7,  Oslash:                    0xd8,

       Ugrave:                    0xd9,  Uacute:                          0xda,

       Ucircumflex:              0xdb,  Udiaeresis:               0xdc,

       Yacute:                    0xdd,  THORN:                                0xde,

       ssharp:                    0xdf,  agrave:                          0xe0,

       aacute:                    0xe1,  acircumflex:            0xe2,

       atilde:                    0xe3,  adiaeresis:              0xe4,

       PROCESSKEY:                0xe5,  ae:                              0xe6,

       PACKET:                    0xe7,  egrave:                          0xe8,

       eacute:                    0xe9,  ecircumflex:            0xea,

       ediaeresis:                0xeb,  igrave:                          0xec,

       iacute:                    0xed,  icircumflex:            0xee,

       idiaeresis:                0xef,  eth:                            0xf0,

       ntilde:                    0xf1,  ograve:                          0xf2,

       oacute:                    0xf3,  ocircumflex:            0xf4,

       otilde:                    0xf5,  ATTN:                          0xf6,

       CRSEL:                          0xf7,  EXSEL:                           0xf8,

       EREOF:                          0xf9,  PLAY:                             0xfa,

       ZOOM:                            0xfb,  NONAME:                    0xfc,

       PA1:                              0xfd,  thorn:                         0xfe,

       ydiaeresis:                0xff

 }

 KEYMAP[:WIN]  = [KEYMAP[:LWIN], KEYMAP[:RWIN]]



 #--------------------------------------------------------------------------

 # * Default Keys, you can configure here instead of by pressing F1.

 #--------------------------------------------------------------------------

 UP    = [KEYMAP[:LETTER_Z]]

 DOWN  = [KEYMAP[:LETTER_S]]

 LEFT  = [KEYMAP[:LETTER_Q]]

 RIGHT = [KEYMAP[:LETTER_D]]

 A      = [KEYMAP[:SHIFT]]

 B      = [KEYMAP[:ESCAPE]]

 C      = [KEYMAP[:RETURN ]]

 X      = []

 Y      = []

 Z      = []

 L      = [KEYMAP[:PRIOR]]

 R      = [KEYMAP[:NEXT]]

 F5    = [KEYMAP[:F5]]

 F6    = [KEYMAP[:F6]]

 F7    = [KEYMAP[:F7]]

 F8    = [KEYMAP[:F8]]

 F9    = [KEYMAP[:F9]]

 SHIFT = [KEYMAP[:SHIFT]]

 CTRL  = [KEYMAP[:CONTROL]]

 ALT   = [KEYMAP[:MENU]]



 #--------------------------------------------------------------------------

 # * Symbol version of default keys.

 #--------------------------------------------------------------------------

 SYM_KEYS = {

       :UP      => UP,

       :LEFT   => LEFT,

       :DOWN   => DOWN,

       :RIGHT  => RIGHT,

       :A        => A,

       :B        => B,

       :C        => C,

       :X        => X,

       :Y        => Y,

       :Z        => Z,

       :L        => L,

       :R        => R,

       :F5      => F5,

       :F6      => F6,

       :F7      => F7,

       :F8      => F8,

       :F9      => F9,

       :SHIFT  => SHIFT,

       :CTRL   => CTRL,

       :ALT    => ALT

 }

 #--------------------------------------------------------------------------

 # * Key Codes Used in Events Conditional Branchs

 #--------------------------------------------------------------------------

 EventsKeyCodes = {

        2 => :DOWN,

        4 => :LEFT,

        6 => :RIGHT,

        8 => :UP,

       11 => :A,

       12 => :B,

       13 => :C,

       14 => :X,

       15 => :Y,

       16 => :Z,

       17 => :L,

       18 => :R

 }

 #--------------------------------------------------------------------------

 # * Internal APIs to handle keyboard functions

 #--------------------------------------------------------------------------

 GetKeyboardState  = Win32API.new("user32.dll", "GetKeyboardState",  "I", "I")

 MapVirtualKeyEx   = Win32API.new("user32.dll", "MapVirtualKeyEx", "IIL", "I")

 ToUnicodeEx      = Win32API.new("user32.dll", "ToUnicodeEx", "LLPPILL", "L")

 #----------

 @language_layout  = Win32API.new("user32.dll", "GetKeyboardLayout", "L", "L").call(0)

 DOWN_STATE_MASK   = (0x8 << 0x04)

 DEAD_KEY_MASK  = (0x8 << 0x1C)

 #-----

 UNICODE_TO_UTF8   = Encoding::Converter.new(Encoding.list[2], Encoding.list[1])



 #--------------------------------------------------------------------------

 # * States of keys

 #--------------------------------------------------------------------------

 @state                        = DL::CPtr.new(DL.malloc(256), 256)

 @triggered            = Array.new(256, false)

 @pressed                = Array.new(256, false)

 @released              = Array.new(256, false)

 @repeated              = Array.new(256, 0)



 #--------------------------------------------------------------------------

 # * Singleton attrs of states

 #--------------------------------------------------------------------------

 class << self

       attr_reader :triggered, :pressed, :released, :repeated, :state

 end



 #--------------------------------------------------------------------------

 # * Get a key code by simbol

 #--------------------------------------------------------------------------

 def self.key(sym)

       KEYMAP[sym] || 0

 end



 #--------------------------------------------------------------------------

 # * Updates input data.

 # As a general rule, this method is called once per frame.

 #--------------------------------------------------------------------------

 def self.update

       GetKeyboardState.call(@state.to_i)

       #-----

       0.upto(255) do |key|

         if @state[key] & DOWN_STATE_MASK == DOWN_STATE_MASK

               @released[key] = false

               @pressed[key]  = true if (@triggered[key] = !@pressed[key])

               @repeated[key] < 17 ? @repeated[key] += 1 : @repeated[key] = 15

         elsif !@released[key] and @pressed[key]

               @triggered[key] = false

               @pressed[key]   = false

               @repeated[key]  = 0

               @released[key]  = true

         else

               @released[key]  = false

         end

       end

 end



 #--------------------------------------------------------------------------

 # * Checks the status of the directional buttons, translates the data into

 # a specialized 4-direction input format, and returns the number pad

 # equivalent (2, 4, 6, 8).

 #

 # If no directional buttons are being pressed (or the equivalent), returns 0.

 #--------------------------------------------------------------------------

 def self.dir4

       return 2 if self.press?(DOWN)

       return 4 if self.press?(LEFT)

       return 6 if self.press?(RIGHT)

       return 8 if self.press?(UP)

       return 0

 end



 #--------------------------------------------------------------------------

 # * Checks the status of the directional buttons, translates the data into

 # a specialized 8-direction input format, and returns the number pad

 # equivalent (1, 2, 3, 4, 6, 7, 8, 9).

 #

 #If no directional buttons are being pressed (or the equivalent), returns 0.

 #--------------------------------------------------------------------------

 def self.dir8

       down = self.press?(DOWN)

       left = self.press?(LEFT)

       return 1 if down and left

       right = self.press?(RIGHT)

       return 3 if down and right

       up = self.press?(UP)

       return 7 if up and left

       return 9 if up and right

       return 2 if down

       return 4 if left

       return 6 if right

       return 8 if up

       return 0

 end



 #--------------------------------------------------------------------------

 # * Determines whether the button corresponding to the symbol sym is

 # currently being pressed.

 #

 # If the button is being pressed, returns TRUE. If not, returns FALSE.

 #

 #   if Input.press?(:C)

 #      do_something

 #   end

 #--------------------------------------------------------------------------

 def self.press?(keys)

       if keys.is_a?(Numeric)

         k = keys.to_i

         return (@pressed[k] and !@triggered[k])

       elsif keys.is_a?(Array)

         return keys.any? {|key| self.press?(key) }

       elsif keys.is_a?(Symbol)

         if SYM_KEYS.key?(keys)

               return SYM_KEYS[keys].any? {|key| (@pressed[key]  and !@triggered[key]) }

         elsif (KEYMAP.key?(keys))

               k = KEYMAP[keys]

               return (@pressed[k] and !@triggered[k])

         else

               return false

         end

       end

 end



 #--------------------------------------------------------------------------

 # * Determines whether the button corresponding to the symbol sym is

 # currently being pressed again.

 # "Pressed again" is seen as time having passed between the button being

 # not pressed and being pressed.

 #

 # If the button is being pressed, returns TRUE. If not, returns FALSE.

 #--------------------------------------------------------------------------

 def self.trigger?(keys)

       if keys.is_a?(Numeric)

         return @triggered[keys.to_i]

       elsif keys.is_a?(Array)

         return keys.any? {|key| @triggered[key]}

       elsif keys.is_a?(Symbol)

         if SYM_KEYS.key?(keys)

               return SYM_KEYS[keys].any? {|key| @triggered[key]}

         elsif KEYMAP.key?(keys)

               return @triggered[KEYMAP[keys]]

         else

               return false

         end

       end

 end



 #--------------------------------------------------------------------------

 # * Determines whether the button corresponding to the symbol sym is

 # currently being pressed again.

 # Unlike trigger?, takes into account the repeated input of a button being

 # held down continuously.

 #

 # If the button is being pressed, returns TRUE. If not, returns FALSE.

 #--------------------------------------------------------------------------

 def self.repeat?(keys)

       if keys.is_a?(Numeric)

         key = keys.to_i

         return @repeated[key] == 1 || @repeated[key] == 16

       elsif keys.is_a?(Array)

         return keys.any? {|key| @repeated[key] == 1 || @repeated[key] == 16}

       elsif keys.is_a?(Symbol)

         if SYM_KEYS.key?(keys)

               return SYM_KEYS[keys].any? {|key| @repeated[key] == 1 || @repeated[key] == 16}

         elsif KEYMAP.key?(keys)

               return @repeated[KEYMAP[keys]] == 1 || @repeated[KEYMAP[keys]] == 16

         else

               return false

         end

       end

 end



 #--------------------------------------------------------------------------

 # * Determines whether the button corresponding to the symbol sym

 # was released.

 #

 # If the button was released, returns TRUE. If not, returns FALSE.

 #--------------------------------------------------------------------------

 def self.release?(keys)

       if keys.is_a?(Numeric)

         return @released[keys.to_i]

       elsif keys.is_a?(Array)

         return keys.any? {|key| @released[key]}

       elsif keys.is_a?(Symbol)

         if SYM_KEYS.key?(keys)

               return SYM_KEYS[keys].any? {|key| @released[key]}

         elsif KEYMAP.key?(keys)

               return @released[KEYMAP[keys]]

         else

               return false

         end

       end

 end



 #--------------------------------------------------------------------------

 # * Gets the character that correspond to vk using the keyboard layout

 #--------------------------------------------------------------------------

 def self.get_character(vk)

       c = MapVirtualKeyEx.call(vk, 2, @language_layout)

       return "" if c < 32 && (c & DEAD_KEY_MASK != DEAD_KEY_MASK)

       #-----

       result = "\0" * 2

       length = ToUnicodeEx.call(vk, MapVirtualKeyEx.call(vk, 0, @language_layout),

                                                         @state, result, 2, 0, @language_layout)

       #-----

       return (length == 0 ? "" : result)

 end



 #--------------------------------------------------------------------------

 # * Accents Table, to bo used in conversion from ASCII to UTF8

 #--------------------------------------------------------------------------

 AccentsCharsConv = {

       "A" =>  ["A", "A", "A", "A", "A"],

       "E" =>  ["E", "E", "E",  0,  "E"],

       "I" =>  ["I", "I", "I",  0,  "I"],

       "O" =>  ["O", "O", "O", "O", "O"],

       "U" =>  ["U", "U", "U",  0,  "U"],

       "C" =>  [ 0 , "C",  0 ,  0,  0 ],

       "N" =>  [ 0 ,  0,  0 , "N",  0 ],

       "Y" =>  [ 0 , "Y",  0 ,  0,  "?"],

       "a" =>  ["a", "a", "a", "a", "a"],

       "e" =>  ["e", "e", "e",  0 , "e"],

       "i" =>  ["i", "i", "i",  0 , "i"],

       "o" =>  ["o", "o", "o", "o", "o"],

       "u" =>  ["u", "u", "u",  0 , "u"],

       "c" =>  [ 0 , "c",  0 ,  0 ,  0 ],

       "n" =>  [ 0 ,  0 ,  0 , "n",  0 ],

       "y" =>  [ 0 , "y",  0 ,  0 , "y"],

 }

 # Letters that can have accent

 PssbLetters   = "AEIOUCNYaeioucny"

 # Accents, in ASCII, configured at runtime to avoid encoding troubles

 Accents               = [96.chr, 180.chr, 94.chr, 126.chr, 168.chr].join

 NonCompatChars = [180, 168]

 @last_accent  = nil



 #--------------------------------------------------------------------------

 # * Get inputed string transcoded to UTF8

 #--------------------------------------------------------------------------

 def self.UTF8String

       result = ""

       31.upto(255) {|key|

               if self.repeat?(key)

                 c = self.get_character(key)

                 if (cc = c.unpack("C")[0]) and NonCompatChars.include?(cc)

                       result += cc.chr

                 else

                       result += UNICODE_TO_UTF8.convertc if c != ""

                 end

               end

       }

       return "" if result == ""

       #-----

       if @last_accent

         result          = @last_accent + result

         @last_accent = nil

       end

       f_result = ""

       jump    = false

       for i in 0 ... result.length

         c = result[i]

         if jump

               jump = false

               next

         end

         #-----

         if Accents.include?c

               if (nc = result[i+1]) != nil

                 if PssbLetters.include?(nc)

                       if (ac = AccentsCharsConv[nc][Accents.indexc]) != 0

                         f_result << ac

                         jump = true

                       else

                         f_result << c

                         f_result << nc

                         jump = true

                       end

                 elsif Accents.include?(nc)

                       f_result << c

                       f_result << nc

                       jump = true

                 else

                       f_result << c

                       f_result << nc

                       jump = true

                 end

               else

                 @last_accent = c

               end

         else

               f_result << c

         end

       end

       #-----

       return f_result

 end

 #----------

end

avatar
Moraxe
Membre

Nombre de messages : 15
Age : 18
Localisation : France (paris)
Distinction : aucune
Date d'inscription : 23/03/2013

Résolu Re: [Résolu] Changer les touches directionnelles de base

le Ven 1 Nov 2013 - 15:12
Ce n'est pas un bléme pour les utilisateurs de qwerty il faut faire MAJ+ALT et ces bons (sa peut être aussi : ALT+MAJ ou MAJ+ALT GR)
Ces combinaisons transformerons votre azerty en qwerty et l’inverse si vous possédez un qwerty .
avatar
Elbric
Membre

Nombre de messages : 58
Age : 24
Distinction : aucune
Date d'inscription : 06/03/2013

Résolu Re: [Résolu] Changer les touches directionnelles de base

le Ven 1 Nov 2013 - 16:59
Merci beaucoup ! Smile
avatar
Ewaldar
Membre

Nombre de messages : 1387
Age : 24
Localisation : Suisse
Distinction : aucune
Date d'inscription : 29/12/2011
http://ewaldar.wixsite.com/les-ames-perdues

Résolu Re: [Résolu] Changer les touches directionnelles de base

le Ven 1 Nov 2013 - 17:16
Et pour les suisses qui ont un clavier qwertz, he bien ça ne fonctionnera pas ! C'est pas la mort non plus, mais je sais déjà que je toucherai donc pas à ton projet Wink

Le script peut toujours être utile, en tout cas !
avatar
hashel
Membre

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

Résolu Re: [Résolu] Changer les touches directionnelles de base

le Ven 1 Nov 2013 - 17:24
intéressent !

ps : Sympa ton avatar du Saut de Malchor Wink
avatar
Elbric
Membre

Nombre de messages : 58
Age : 24
Distinction : aucune
Date d'inscription : 06/03/2013

Résolu Re: [Résolu] Changer les touches directionnelles de base

le Sam 2 Nov 2013 - 18:14
Je reviens vers vous car il semblerait que le script que tu m'ais donné pose des problèmes de compatibilité avec un autre script : http://www.rpgmakervx-fr.com/t14749p15-mouse-system#177324

Auriez-vous un autre script à me proposer ou une solution à ce problème ?
avatar
Spytje
Administrateur

Nombre de messages : 5899
Localisation : La terre
Distinction : Spiraliste [Korn']
Forestia : Projet du mois juillet 2014
Papy Pulkigrat [Yama']
Date d'inscription : 16/03/2008

Résolu Re: [Résolu] Changer les touches directionnelles de base

le Sam 2 Nov 2013 - 18:28
Va voir ton autre sujet j'y ai répondu pour ton soucis avec ce script.
avatar
Elbric
Membre

Nombre de messages : 58
Age : 24
Distinction : aucune
Date d'inscription : 06/03/2013

Résolu Re: [Résolu] Changer les touches directionnelles de base

le Sam 2 Nov 2013 - 18:35
Nickel merci beaucoup ! Résolu !
Contenu sponsorisé

Résolu Re: [Résolu] Changer les touches directionnelles de base

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