Jump to content
Rpg²S Forum

Broly88

Utenti
  • Posts

    311
  • Joined

  • Last visited

Posts posted by Broly88

  1. Non solo: in casi specifici come questo bisogna anche mettere degli elementi particolari, come il monte "Rushmore" degli Hokage. Cmq la differenza tra tileset e chipset è solo nel nome: i tileset, infatti, sono quelli di RMXP, mentre i chipset sono quelli dell'RM2K XD
  2. Devi semplicemente prendere tutti gli script che costituiscono questo BS e incollarli nel tuo progetto: apri la demo con l'ABS e premi F11, scorri la lista degli script, clicchi col destro su quelli che ti interessano, fai copia, e poi incolla all'interno del tuo progetto. Chiaro no? XDDD

     

    P.S.: fila a presentarti, fannullone ^___________^

  3. Io ne avevo trovato uno tempo fa, su RMXP.org. L'unica differenza che aveva da quello di FFT era che quest'ultimo era isometrico, mentre quello di RMXP no. Adesso non ce l'ho sotto mano, quindi magari intanto prova tu a fare un salto là...

     

    EDIT: cambio di programma, eccoti il link => QUI

  4. @havana24: si forse hai ragione. Beh comunque la cosa è semplice: facciamo conto che voi volete usare la lettera, che ne so, K, in modo che se la premete succede qualcosa. Intanto precisiamo che la questione non è proprio come l'ha messa Ghalok: se, infatti, supponiamo di voler inserire la possibilità di richiamare qualcosa durante il gioco tramite la pressione della famosa lettera K (chi di voi sta pensando "figo, ci faccio una bella mappa per il mio game" è troppo banale XD), abbiamo la possibilità di optare per due scelte.

     

    Scelta 1 - Script duro e puro

    Creiamo un nuovo script e ci mettiamo dentro questo:

     

    # Creiamo una modifica alla classe Scene_Map
    class Scene_Map
     # Configuriamo un alias, ovvero chiamiamo "my_update",
     # il metodo già esistente "update" della nostra classe
     # Scene_Map
     alias my_upd update
     # Applichiamo la nostra modifica al metodo "update"
     def update
    			# Chiamo il vecchio metodo update
    my_upd
    # Eseguo la parte nuova
    if Input.triggerd?(Input::Letters["K"])
      <Cose da fare, tipo la chiamata ad una nuova scena
       ($scene = Qualcosa.new)>
    end
     end
    end

     

     

    Scelta 2 - Ibrido script/evento

    In questo caso, creiamo un nuovo script e ci mettiamo solo questo:

     

    # Creiamo una modifica alla classe Scene_Map
    class Scene_Map
     # Creiamo un nuovo metodo che faccia quello che vogliamo
     def chiama_mappa	
    <Cose da fare, tipo la chiamata ad una nuova scena
    ($scene = Qualcosa.new)>	
     end
    end

     

     

    A questo punto creiamo un nuovo evento su mappa, mettendoci all'interno un "Conditional Branch" con condizione "Script", in cui scriveremo:

    Input.triggerd?(Input::Letters["K"])

     

    Ecco qua... tutto chiaro? ^______^

  5. coff coff... ehm XD Questa veramente è una cosa che non potresti chiedere così, en plain-air. La patch per rendere RPGXP in ITA è illegale e questo forum non supporta versioni non - legali del software.

     

     

    Cmq prova a chiedere a Marigno in PM, lui dovrebbe avercela... ^_^

     

     

    P.S. : fila a presentarti, lavativo! XD

  6. Io ho un programmino che si chiama SprTool+ per aprire i file *.spr. Uso quello, ma non è l'unico: basta che riesci a mettere le mani su un qualsiasi converter spr -> bmp. Potresti cmq postare il file grf + piccolo se non ti è di troppo disturbo? Vorrei vedere se riesco a rippicchiare qualcosa^^
  7. Cybersam's Keyboard Input Module - Broly88's IT Keyboard Revision

    Descrizione

    Come dice il sottotilo, è la rimappatura italiana del famoso script di Cybersam (scritto per le tastiere ENG).

    Autore

    Cybersam (script base) - Broly88 (rimappatura)


    Screenshots

    In questo caso era un po' difficile...

    Allegati

    Ecco lo script:

     

    #===============================================================================
    # ** Input Script v2 - This script was first created by Cybersam and she 
    #                         deserves most of the credit, all I did was add a few 
    #                         functions. (Astro_Mech says)
    #-------------------------------------------------------------------------------
    # Author    Cybersam
    # Version   2.0
    # Date      11-04-06
    # Edit      Astro_mech and Mr.Mo
    # Revision  Broly88
    #===============================================================================
    
    #===============================================================================
    # REVISIONE ITALIANA - La revisione italiana di questo script è stata a cura del
    # sottoscritto, Broly88. In realtà non ho fatto molto, però ho rimappato tutto 
    # lo script (che era stato progettato per la tastiera inglese) e l'ho adattato
    # alle italiche tastiere, eheheh ^_^ . Ho anche aggiunto alcuni tasti, come
    # quelli presenti sopra alle frecce direzionali e il tastierino numerico. Non 
    # sono ancora però tutti (anche se sono circa il 96%) e se qualcuno volesse     
    # finire il lavoro del sottoscritto... deve solo farlo! XDDD
    #===============================================================================
    
    SDK.log("Input", "Astro_mech and Mr.Mo", "2.0", " 13-04-06")
    #-------------------------------------------------------------------------------
    # Begin SDK Enabled Check
    #-------------------------------------------------------------------------------
    if SDK.state('Input')
    module Input
      #--------------------------------------------------------------------------
      # * Variable Setup
      #-------------------------------------------------------------------------- 
        @keys = []
        @pressed = []
        #-------------------------------------------------------------------------- 
        # MOUSE
        #-------------------------------------------------------------------------- 
        Mouse_Left = 1
        Mouse_Right = 2
        Mouse_Middle = 4
        #-------------------------------------------------------------------------- 
        
        #-------------------------------------------------------------------------- 
        # AREA FRECCETTE DIREZIONALI
        #-------------------------------------------------------------------------- 
        Back= 8                  # Backspace
        Tab = 9                  # Tab
        Enter = 13               # Invio              (entrambi)
        Shift = 16               # Shift              (entrambi)
        Ctrl = 17                # Ctrl               (entrambi)
        Alt = 18                 # Alt                (entrambi)
        Esc = 0x1B               # Esc
        LT = 0x25                # Frecce Direzionali (Sinistra)
        UPs = 0x26               # Frecce Direzionali (Su)
        RT = 0x27                # Frecce Direzionali (Destra)
        DN = 0x28                # Frecce Direzionali (Giù)
        Space = 32               # Spazio
        INS = 45                 # Ins                (entrambi)
        Home = 36                # Home
        PagUp = 33               # Pag Up
        Del = 46                 # Canc
        End = 35                 # Fine
        PagDwn = 34              # Pag Down
        #-------------------------------------------------------------------------- 
        
        #-------------------------------------------------------------------------- 
        # NUMERI
        #-------------------------------------------------------------------------- 
        Numberkeys = {}
        Numberkeys[0] = 48        # 0
        Numberkeys[1] = 49        # 1
        Numberkeys[2] = 50        # 2
        Numberkeys[3] = 51        # 3
        Numberkeys[4] = 52        # 4
        Numberkeys[5] = 53        # 5
        Numberkeys[6] = 54        # 6
        Numberkeys[7] = 55        # 7
        Numberkeys[8] = 56        # 8
        Numberkeys[9] = 57        # 9
        #-------------------------------------------------------------------------- 
        
        #-------------------------------------------------------------------------- 
        # TASTIERINO NUMERICO - Parte 1 (Numeri)
        #-------------------------------------------------------------------------- 
        Numberpad = {}    
        Numberpad[0] = 96         # 0
        Numberpad[1] = 97         # 1
        Numberpad[2] = 98         # 2
        Numberpad[3] = 99         # 3
        Numberpad[4] = 100        # 4
        Numberpad[5] = 101        # 5
        Numberpad[6] = 102        # 6
        Numberpad[7] = 103        # 7
        Numberpad[8] = 104        # 8
        Numberpad[9] = 105        # 9
        #-------------------------------------------------------------------------- 
        
        #-------------------------------------------------------------------------- 
        # TASTIERINO NUMERICO - Parte 2 (Operatori)
        #--------------------------------------------------------------------------
        OperSymb = {}
        OperSymb["/"] = 111       # Divisione
        OperSymb["*"] = 106       # Moltiplicazione
        OperSymb["-"] = 109       # Sottrazione
        OperSymb["+"] = 107       # Addizione
        #--------------------------------------------------------------------------
        
        #--------------------------------------------------------------------------
        # LETTERE
        #--------------------------------------------------------------------------
        Letters = {}
        Letters["A"] = 65
        Letters["B"] = 66
        Letters["C"] = 67
        Letters["D"] = 68
        Letters["E"] = 69
        Letters["F"] = 70
        Letters["G"] = 71
        Letters["H"] = 72
        Letters["I"] = 73
        Letters["J"] = 74
        Letters["K"] = 75
        Letters["L"] = 76
        Letters["M"] = 77
        Letters["N"] = 78
        Letters["O"] = 79
        Letters["P"] = 80
        Letters["Q"] = 81
        Letters["R"] = 82
        Letters["S"] = 83
        Letters["T"] = 84
        Letters["U"] = 85
        Letters["V"] = 86
        Letters["W"] = 87
        Letters["X"] = 88
        Letters["Y"] = 89
        Letters["Z"] = 90
        #--------------------------------------------------------------------------
        
        #--------------------------------------------------------------------------
        # TASTI F (F1, F2, F3, ecc...)
        #--------------------------------------------------------------------------
        Fkeys = {}
        Fkeys[1] = 112
        Fkeys[2] = 113
        Fkeys[3] = 114
        Fkeys[4] = 115
        Fkeys[5] = 116
        Fkeys[6] = 117
        Fkeys[7] = 118
        Fkeys[8] = 119
        Fkeys[9] = 120
        Fkeys[10] = 121
        Fkeys[11] = 122
        Fkeys[12] = 123
        #--------------------------------------------------------------------------
        
        #--------------------------------------------------------------------------
        # SIMBOLI - Alcuni nomi non sono corretti : vedere le rappresentazioni a 
        # destra. La prima è il tasto normale, la seconda è la combinazione col 
        # tasto [shift].
        #--------------------------------------------------------------------------
        Collon = 186        # => è é    
        Equal = 187         # => = +
        Comma = 188         # => , ;
        Underscore = 189    # => - _
        Dot = 190           # => . :    
        Backslash = 220     # => \ |    
        Apos = 219          # => ' ?
        Eleva = 221         # => ì ^
        MaxMin = 226        # => < >
        O_Acc = 192         # => ò ç
        U_Acc = 191         # => ù §
        Quote = 222         # => à °
        #--------------------------------------------------------------------------
        
        State = Win32API.new('user32','GetKeyState',['i'],'i')
        Key = Win32API.new('user32','GetAsyncKeyState',['i'],'i')
    #-------------------------------------------------------------------------------
        USED_KEYS = [Mouse_Left, Mouse_Right, Mouse_Middle] 
    #-------------------------------------------------------------------------------
      module_function
        #--------------------------------------------------------------------------  
        def Input.getstate(key)
          return true unless State.call(key).between?(0, 1)
          return false
        end
        #--------------------------------------------------------------------------
        def Input.testkey(key)
          Key.call(key) & 0x01 == 1
        end
        #--------------------------------------------------------------------------
        def Input.update      
          @keys = []
          @keys.push(Input::Mouse_Left) if Input.testkey(Input::Mouse_Left)
          @keys.push(Input::Mouse_Right) if Input.testkey(Input::Mouse_Right)
          @keys.push(Input::Back) if Input.testkey(Input::Back)
          @keys.push(Input::Tab) if Input.testkey(Input::Tab)
          @keys.push(Input::Enter) if Input.testkey(Input::Enter)
          @keys.push(Input::Shift) if Input.testkey(Input::Shift)
          @keys.push(Input::Ctrl) if Input.testkey(Input::Ctrl)
          @keys.push(Input::Alt) if Input.testkey(Input::Alt)
          @keys.push(Input::Esc) if Input.testkey(Input::Esc)
          for key in Input::Letters.values
            @keys.push(key) if Input.testkey(key)
          end
          for key in Input::Numberkeys.values
            @keys.push(key) if Input.testkey(key)
          end
          for key in Input::Numberpad.values
            @keys.push(key) if Input.testkey(key)
          end
          for key in Input::OperSymb.values
            @keys.push(key) if Input.testkey(key)
          end
          for key in Input::Fkeys.values
            @keys.push(key) if Input.testkey(key)
          end
          @keys.push(Input::Collon) if Input.testkey(Input::Collon)
          @keys.push(Input::Equal) if Input.testkey(Input::Equal)
          @keys.push(Input::Comma) if Input.testkey(Input::Comma)
          @keys.push(Input::Underscore) if Input.testkey(Input::Underscore)
          @keys.push(Input::Dot) if Input.testkey(Input::Dot)
          @keys.push(Input::Backslash) if Input.testkey(Input::Backslash)      
          @keys.push(Input::Apos) if Input.testkey(Input::Apos)
          @keys.push(Input::Eleva) if Input.testkey(Input::Eleva)
          @keys.push(Input::MaxMin) if Input.testkey(Input::MaxMin)
          @keys.push(Input::O_Acc) if Input.testkey(Input::O_Acc)
          @keys.push(Input::U_Acc) if Input.testkey(Input::U_Acc)
          @keys.push(Input::Quote) if Input.testkey(Input::Quote)
          @keys.push(Input::Space) if Input.testkey(Input::Space)
          @keys.push(Input::INS) if Input.testkey(Input::INS)
          @keys.push(Input::Home) if Input.testkey(Input::Home)
          @keys.push(Input::PagUp) if Input.testkey(Input::PagUp)
          @keys.push(Input::Del) if Input.testkey(Input::Del)
          @keys.push(Input::End) if Input.testkey(Input::End)
          @keys.push(Input::PagDwn) if Input.testkey(Input::PagDwn)
          @keys.push(Input::LT) if Input.testkey(Input::LT)
          @keys.push(Input::UPs) if Input.testkey(Input::UPs)
          @keys.push(Input::RT) if Input.testkey(Input::RT)
          @keys.push(Input::DN) if Input.testkey(Input::DN)
          @pressed = []
          @pressed.push(Input::Space) if Input.getstate(Input::Space)
          @pressed.push(Input::INS) if Input.getstate(Input::INS)
          @pressed.push(Input::Home) if Input.getstate(Input::Home)
          @pressed.push(Input::PagUp) if Input.getstate(Input::PagUp)
          @pressed.push(Input::Del) if Input.getstate(Input::Del)
          @pressed.push(Input::PagDwn) if Input.getstate(Input::PagDwn)
          @pressed.push(Input::INS) if Input.getstate(Input::INS)
          @pressed.push(Input::Mouse_Left) if Input.getstate(Input::Mouse_Left)
          @pressed.push(Input::Mouse_Right) if Input.getstate(Input::Mouse_Right)
          @pressed.push(Input::Back) if Input.getstate(Input::Back)
          @pressed.push(Input::Tab) if Input.getstate(Input::Tab)
          @pressed.push(Input::Enter) if Input.getstate(Input::Enter)
          @pressed.push(Input::Shift) if Input.getstate(Input::Shift)
          @pressed.push(Input::Ctrl) if Input.getstate(Input::Ctrl)
          @pressed.push(Input::Alt) if Input.getstate(Input::Alt)
          @pressed.push(Input::Esc) if Input.getstate(Input::Esc)
          @pressed.push(Input::LT) if Input.getstate(Input::LT)
          @pressed.push(Input::UPs) if Input.getstate(Input::UPs)
          @pressed.push(Input::RT) if Input.getstate(Input::RT)
          @pressed.push(Input::DN) if Input.getstate(Input::DN)
          for key in Input::Numberkeys.values
            @pressed.push(key) if Input.getstate(key)
          end
          for key in Input::Numberpad.values
            @pressed.push(key) if Input.getstate(key)
          end
          for key in Input::OperSymb.values
            @pressed.push(key) if Input.getstate(key)
          end
          for key in Input::Letters.values
            @pressed.push(key) if Input.getstate(key)
          end
          for key in Input::Fkeys.values
            @pressed.push(key) if Input.getstate(key)
          end
          @pressed.push(Input::Collon) if Input.getstate(Input::Collon)
          @pressed.push(Input::Equal) if Input.getstate(Input::Equal)
          @pressed.push(Input::Comma) if Input.getstate(Input::Comma)
          @pressed.push(Input::Underscore) if Input.getstate(Input::Underscore)
          @pressed.push(Input::Dot) if Input.getstate(Input::Dot)
          @pressed.push(Input::Backslash) if Input.getstate(Input::Backslash)      
          @pressed.push(Input::Apos) if Input.getstate(Input::Apos)
          @pressed.push(Input::Eleva) if Input.getstate(Input::Eleva)
          @pressed.push(Input::MaxMin) if Input.getstate(Input::MaxMin)
          @pressed.push(Input::O_Acc) if Input.getstate(Input::O_Acc)
          @pressed.push(Input::U_Acc) if Input.getstate(Input::U_Acc)
          @pressed.push(Input::Quote) if Input.getstate(Input::Quote)  
        end
        #--------------------------------------------------------------------------
        def Input.triggerd?(key)
          return true if @keys.include?(key)
          return false
        end
        #--------------------------------------------------------------------------
        def Input.pressed?(key)
          return true if @pressed.include?(key)
          return false
        end
      #--------------------------------------------------------------------------
      # * 4 Direction
      #--------------------------------------------------------------------------
      def Input.dir4
        return 2 if Input.pressed?(Input::DN)
        return 4 if Input.pressed?(Input::LT)
        return 6 if Input.pressed?(Input::RT)
        return 8 if Input.pressed?(Input::UPs)
        return 0
      end
      #--------------------------------------------------------------------------
      # * Trigger (key)
      #-------------------------------------------------------------------------- 
      def trigger?(key)
        keys = []
        case key
        when Input::DOWN
          keys.push(Input::DN)
        when Input::UP
          keys.push(Input::UPs)
        when Input::LEFT
          keys.push(Input::LT)
        when Input::RIGHT
          keys.push(Input::RT)
        when Input::C
          keys.push(Input::Space, Input::Enter)
        when Input::B
          keys.push(Input::Esc, Input::INS)
        when Input::X
          keys.push(Input::Letters["A"])
        when Input::L
          keys.push(Input::Letters["Q"])
        when Input::R
          keys.push(Input::Letters["W"])
        when Input::Y
          keys.push(Input::Letters["R"])
        when Input::F5
          keys.push(Input::Fkeys[5])
        when Input::F6
          keys.push(Input::Fkeys[6])
        when Input::F7
          keys.push(Input::Fkeys[7])
        when Input::F8
          keys.push(Input::Fkeys[8])
        when Input::F9
          keys.push(Input::Fkeys[9])
        when Input::SHIFT
          keys.push(Input::Shift)
        when Input::CTRL
          keys.push(Input::Ctrl)
        when Input::ALT
          keys.push(Input::Alt)
        else
          keys.push(key)
        end    
        for k in keys
         if Input.triggerd?(k)
           return true
         end
       end
       return false
     end
      #--------------------------------------------------------------------------
      # * Repeat (key)
      #-------------------------------------------------------------------------- 
      def repeat?(key)
        keys = []
        case key
        when Input::DOWN
          keys.push(Input::DN)
        when Input::UP
          keys.push(Input::UPs)
        when Input::LEFT
          keys.push(Input::LT)
        when Input::RIGHT
          keys.push(Input::RT)
        when Input::C
          keys.push(Input::Space, Input::Enter)
        when Input::B
          keys.push(Input::Esc, Input::INS)
        when Input::X
          keys.push(Input::Letters["A"])
        when Input::L
          keys.push(Input::Letters["Q"])
        when Input::R
          keys.push(Input::Letters["W"])
        when Input::Y
          keys.push(Input::Letters["R"])
        when Input::F5
          keys.push(Input::Fkeys[5])
        when Input::F6
          keys.push(Input::Fkeys[6])
        when Input::F7
          keys.push(Input::Fkeys[7])
        when Input::F8
          keys.push(Input::Fkeys[8])
        when Input::F9
          keys.push(Input::Fkeys[9])
        when Input::SHIFT
          keys.push(Input::Shift)
        when Input::CTRL
          keys.push(Input::Ctrl)
        when Input::ALT
          keys.push(Input::Alt)
        else
          keys.push(key)
        end
        for k in keys
         if Input.triggerd?(k)
           return true
         end
       end
       return false
      end
      #--------------------------------------------------------------------------
      # * Press (key)
      #-------------------------------------------------------------------------- 
      def press?(key)
        keys = []
        case key
        when Input::DOWN
          keys.push(Input::DN)
        when Input::UP
          keys.push(Input::UPs)
        when Input::LEFT
          keys.push(Input::LT)
        when Input::RIGHT
          keys.push(Input::RT)
        when Input::C
          keys.push(Input::Space, Input::Enter)
        when Input::B
          keys.push(Input::Esc, Input::Numberpad[0])
        when Input::X
          keys.push(Input::Letters["A"])
        when Input::L
          keys.push(Input::Letters["Q"])
        when Input::R
          keys.push(Input::Letters["W"])
        when Input::Y
          keys.push(Input::Letters["R"])
        when Input::F5
          keys.push(Input::Fkeys[5])
        when Input::F6
          keys.push(Input::Fkeys[6])
        when Input::F7
          keys.push(Input::Fkeys[7])
        when Input::F8
          keys.push(Input::Fkeys[8])
        when Input::F9
          keys.push(Input::Fkeys[9])
        when Input::SHIFT
          keys.push(Input::Shift)
        when Input::CTRL
          keys.push(Input::Ctrl)
        when Input::ALT
          keys.push(Input::Alt)
        else
          keys.push(key)
        end
        for k in keys
         if Input.pressed?(k)
           return true
         end
       end
       return false
      end
      #--------------------------------------------------------------------------
      # * Check (key)
      #-------------------------------------------------------------------------- 
      def check(key)
        Win32API.new("user32","GetAsyncKeyState",['i'],'i').call(key) & 0x01 == 1  # key 0
      end
      #--------------------------------------------------------------------------
      # * Mouse Update
      #-------------------------------------------------------------------------- 
      def mouse_update
        @used_i = []
        for i in USED_KEYS
          x = check(i)
          if x == true
            @used_i.push(i)
          end
        end
      end
      #--------------------------------------------------------------------------
      # * Short Write C
      #-------------------------------------------------------------------------- 
      def Input.C
        Input.trigger?(C)
      end
      #--------------------------------------------------------------------------
      # * Short Write B
      #-------------------------------------------------------------------------- 
      def Input.B
        Input.trigger?(B)
      end
      #--------------------------------------------------------------------------
      # * Short Write A
      #-------------------------------------------------------------------------- 
      def Input.A
        Input.trigger?(A)
      end
      #--------------------------------------------------------------------------
      # * Short Write Down
      #-------------------------------------------------------------------------- 
      def Input.Down
        Input.trigger?(DOWN)
      end
      #--------------------------------------------------------------------------
      # * Short Write Up
      #-------------------------------------------------------------------------- 
      def Input.Up
        Input.trigger?(UP)
      end
      #--------------------------------------------------------------------------
      # * Short Write Right
      #-------------------------------------------------------------------------- 
      def Input.Right
        Input.trigger?(RIGHT)
      end
      #--------------------------------------------------------------------------
      # * Short Write Left
      #-------------------------------------------------------------------------- 
      def Input.Left
        Input.trigger?(LEFT)
      end
      #--------------------------------------------------------------------------
      # * Anykey pressed?  ( A or B or C or Down or Up or Right or Left )
      #-------------------------------------------------------------------------- 
      def Input.Anykey
        if A or B or C or Down or Up or Right or Left
          return true
        else
          return false
        end
      end
    end
    end
    #-------------------------------------------------------------------------------
    # End SDK Enabled Check
    #-------------------------------------------------------------------------------
     

     

     


    Scusate, ma non so come si mette lo spoiler XD... anzi, se qualcuno me lo spiega... ^_^

    Istruzioni per l'uso

    Richiede l'SDK, basta solo incollarcelo sotto XD.

  8. Beh su quello non credo che potrai trovara molto di meglio. Il fatto sta tutto nel riuscire ad associare ad un oggetto, una serie di ingredienti. Come in ogni buona ricetta, l'ingrediente ha una sua identità (che viene individuata dal suo indice nel database e dalla sua tipologia) e una sua quantità. E poi gli ingredienti sono + di uno, per ogni oggetto da forgiare. Io in pratica non ho fatto altro che utilizzare degli Hash per convertire l'indice del risultato e la sua tipologia, nella lista dei suoi ingredienti. Quello che ho usato è secondo me il metodo più efficace, ma se ne avete altri ditemeli pure ^______^
×
×
  • Create New...