Плохо! Плохо!:  0
Показано с 1 по 3 из 3

Тема: Графа VX > Графа ХР. У кого есть прога-преобразователь?

  1. #1
    Маститый Аватар для Nalia
    Информация о пользователе
    Регистрация
    18.09.2009
    Адрес
    Пенза
    Сообщений
    1,371
    Записей в дневнике
    104
    Репутация: 78 Добавить или отнять репутацию

    По умолчанию Графа VX > Графа ХР. У кого есть прога-преобразователь?

    Задумала поиграться с графикой вехи. Конечно, преобразовать можно с помощью фотошопа, но эта работа страшно нудная и однообразная. Так что. Знаю, есть какие-то программы-преобразователи. Никто не поделится?
    Я отрицаю вашу реальность и заменю её своей. (c) Джон Адам Севидж

    Надо работать, работать надо. Ремешки под касками затянуть потуже, шинели в порядок привести, в кобуру засунуть трудолюбие 36 калибра и марш за мейкер! (с) Tall Men

  2. #2
    Мастер Форума Аватар для Рольф
    Информация о пользователе
    Регистрация
    14.04.2008
    Адрес
    Южно- Сахалинск/Пенза
    Сообщений
    8,400
    Записей в дневнике
    2
    Репутация: 91 Добавить или отнять репутацию

    По умолчанию

    Я тоже заметил парочку интересного в графике новой. Пока ручками вырезаю.

  3. #3
    Maker XP Аватар для Bullet S.D.
    Информация о пользователе
    Регистрация
    27.01.2009
    Адрес
    Москва
    Сообщений
    1,337
    Записей в дневнике
    10
    Репутация: 72 Добавить или отнять репутацию

    По умолчанию

    Пока только для чаров нашёл. Она старая.

    http://rpgmaker.su/downloads.php?do=file&id=87


    И скрипт, который якобы должен конвертировать VX в ХР. Но я его не пробовал, да и не хочу.


    Спойлер Скрипт:
    Код:
    class VX_to_XP
      def initialize(quelle,ziel,type,shutdown=false)
        @quelle = quelle
        @ziel = ziel
     
        # Führe entsprechende Methode aus
        if type == "Characters" then
          load_characters
        elsif type == "Faces" then
          load_faces
        elsif type == "Tile" then
          load_tiles
        elsif type == "Balloon" then
          load_balloon
        elsif type == "Icons" then
          load_icons
        elsif type == "A1" or type == "A2" or type == "A3" or type == "A4" then
          load_autotile(type)
        elsif type == "Bigchar" then
          load_bigchar
        end
     
        # Wenn shutdown true ist, beende das Programm
        if shutdown == true then
          $scene = nil
        end
      end
     
     
      def load_characters
        # Erstelle original-Sprite
        original = Sprite.new
        # Erstelle original-Bitmap
        original.bitmap = Bitmap.new(@quelle)
        # Speichere original-Bitmap Höhe und Breite
        block_breite = original.bitmap.width / 4
        block_hoehe = original.bitmap.height / 2
     
        # Erstelle neuen Array
        @new_bitmap = Array.new(8)
        for br in 1..4
          for he in [0,1]
     
            # Errechne Additionswert add
            if he == 0
              then add = 0
              else add = 4
            end
     
            #Erstelle neuen Sprite
            @new_bitmap[br+add] = Sprite.new
            #Erstelle neues Bitmap
            @new_bitmap[br+add].bitmap = Bitmap.new(block_breite+(block_breite/3),block_hoehe)
            #Setzte Rect fest
            ausschnitt = Rect.new(((br-1)*block_breite)+(block_breite/3),he*block_hoehe,block_breite/3,block_hoehe)
            #Kopiere Ausschnitt
            @new_bitmap[br+add].bitmap.blt(0,0,original.bitmap,ausschnitt)
            #Setzte Rect fest
            ausschnitt = Rect.new((br-1)*block_breite,he*block_hoehe,block_breite,block_hoehe)
            #Kopiere Ausschnitt
            @new_bitmap[br+add].bitmap.blt(block_breite/3,0,original.bitmap,ausschnitt)
     
          end
        end
        #Lösche den original-Sprite
        original.dispose
        #Speichere die Bitmaps
        for number in 1..8
          @new_bitmap[number].bitmap.make_png("#{@ziel} - #{number}")
          @new_bitmap[number].dispose
        end
      end
     
      def load_tiles
        # Erstelle original-Sprite
        original = Sprite.new
        # Erstelle original-Bitmap
        original.bitmap = Bitmap.new(@quelle)
        #Erstelle neuen Sprite
        @new_bitmap = Sprite.new
        #Erstelle neues Bitmap
        @new_bitmap.bitmap = Bitmap.new(256,1024)
        #Setzte Rect fest
        ausschnitt = Rect.new(0,0,256,512)
        #Kopiere Ausschnitt
        @new_bitmap.bitmap.blt(0,0,original.bitmap,ausschnitt)
        #Ändere Rect
        ausschnitt.x = 256
        #Kopiere Ausschnitt
        @new_bitmap.bitmap.blt(0,512,original.bitmap,ausschnitt)
        #Lösche den original-Sprite
        original.dispose
        #Speichere die Bitmaps
        @new_bitmap.bitmap.make_png("#{@ziel}")
        @new_bitmap.dispose
      end
     
      def load_faces
        # Erstelle original-Sprite
        original = Sprite.new
        # Erstelle original-Bitmap
        original.bitmap = Bitmap.new(@quelle)
        # Speichere original-Bitmap Höhe und Breite
        block_breite = original.bitmap.width / 4
        block_hoehe = original.bitmap.height / 2
     
        # Erstelle neuen Array
        @new_bitmap = Array.new(8)
        for br in 1..4
          for he in [0,1]
     
            # Errechne Additionswert add
            if he == 0
              then add = 0
              else add = 4
            end
     
            #Erstelle neuen Sprite
            @new_bitmap[br+add] = Sprite.new
            #Erstelle neues Bitmap
            @new_bitmap[br+add].bitmap = Bitmap.new(block_breite,block_hoehe)
            #Setzte Rect fest
            ausschnitt = Rect.new((br-1)*block_breite,he*block_hoehe,block_breite,block_hoehe)
            #Kopiere Ausschnitt
            @new_bitmap[br+add].bitmap.blt(0,0,original.bitmap,ausschnitt)
     
          end
        end
        #Lösche den original-Sprite
        original.dispose
        #Speichere die Bitmaps
        for number in 1..8
          @new_bitmap[number].bitmap.make_png("#{@ziel} - #{number}")
          @new_bitmap[number].dispose
        end
      end
     
      def load_balloon
        # Erstelle original-Sprite
        original = Sprite.new
        # Erstelle original-Bitmap
        original.bitmap = Bitmap.new(@quelle)
        #Erstelle neuen Array
        @new_bitmap = Array.new(10)
        for nr in 1..10
          #Erstelle neuen Sprite
          @new_bitmap[nr] = Sprite.new
          #Erstelle neues Bitmap
          @new_bitmap[nr].bitmap = Bitmap.new(960,384)
        end
     
        for hoehe in 0..9
          for breite in 0..7
            #Lege Rect fest
            ausschnitt = Rect.new(breite*32,hoehe*32,32,32)
            # Bestimme anim
            if breite <= 4 then
              anim = breite, 0
            else
              anim = breite-5, 1
            end
            #Kopiere Ausschnitt auf @new_bitmap
            @new_bitmap[hoehe+1].bitmap.blt((192*anim[0])+80,80+(192*anim[1]),original.bitmap,ausschnitt)
          end
        end
        #Lösche den original-Sprite
        original.dispose
        #Speichere die Bitmaps
        for number in 1..10
          @new_bitmap[number].bitmap.make_png("#{@ziel} - #{number}")
          @new_bitmap[number].dispose
        end
      end
     
      def load_icons
        # Erstelle original-Sprite
        original = Sprite.new
        # Erstelle original-Bitmap
        original.bitmap = Bitmap.new(@quelle)
        #Lese Iconanzahl fest
        iconsx = original.bitmap.width/24
        iconsy = original.bitmap.height/24
        #Erstelle neuen Array
        @new_bitmap = Array.new(iconsx*iconsy)
        for nr in 1..@new_bitmap.size
          #Erstelle neuen Sprite
          @new_bitmap[nr] = Sprite.new
          #Erstelle neues Bitmap
          @new_bitmap[nr].bitmap = Bitmap.new(24,24)
        end
        add = 1
        for breite in 1..iconsx
          for hoehe in 1..iconsy
            #Lege Rect fest
            ausschnitt = Rect.new(24*(breite-1),24*(hoehe-1),24,24)
            #Kopere ausschnitt auf @new_bitmap
            @new_bitmap[add].bitmap.blt(0,0,original.bitmap,ausschnitt)
            @new_bitmap[add].y = (breite+add)*24
            add += 1
          end
        end
        #Lösche den original-Sprite
        original.dispose
        #Speichere die Bitmaps
        for number in 1..@new_bitmap.size-1
          @new_bitmap[number].bitmap.make_png("#{@ziel} - #{number}")
          @new_bitmap[number].dispose
        end
      end
     
      def tileA1
        # Erstelle original-Sprite
        original = Sprite.new
        # Erstelle original-Bitmap
        original.bitmap = Bitmap.new(@quelle)
     
        # KONVERTIERE "WASSER"-AUTOTILES
     
        @new_bitmap = Array.new(16)
        add = 0
        for hoehe in 0..3
          for breite in 0..1
            add += 1
            @new_bitmap[add] = Sprite.new
            @new_bitmap[add].bitmap = Bitmap.new(288,128)
            for animation in 0..2
              convert_auto((64*animation)+(breite*256),hoehe*96,original.bitmap)
              ausschnitt = Rect.new(0,0,96,128)
              @new_bitmap[add].bitmap.blt(animation*96,0,$autotile_bitmap,ausschnitt)
            end
            $autotile_bitmap.dispose
          end
        end
     
        # KONVERTIERE "WASSERFALL"-AUTOTILES
        wasserfall = Array.new(8)
        add = 0
     
        #Wandle Wasserfälle in normale VX-Autotiles
        for hoehe in 0..3
          for breite in 0..1
            if breite == 1 or hoehe > 1 then
              add += 1
              wasserfall[add] = Bitmap.new(192,96)
              for animation in 0..2
                #Erstelle Anzeige-Bild
                rect = Rect.new(192+(breite*256),(hoehe*96)+(animation*32),16,16)
                wasserfall[add].blt(animation*64,0,original.bitmap,rect)
                rect.x += 48
                wasserfall[add].blt(16+(animation*64),0,original.bitmap,rect)
                rect.x -= 48
                rect.y += 16
                wasserfall[add].blt(animation*64,16,original.bitmap,rect)
                rect.x += 48
                wasserfall[add].blt(16+(animation*64),16,original.bitmap,rect)
     
                #Erstelle Autotile-Rand
                rect = Rect.new(animation*64,0,16,16)
                wasserfall[add].blt(animation*64,32,wasserfall[add],rect)
                wasserfall[add].blt(animation*64,64,wasserfall[add],rect)
                rect.x += 16
                wasserfall[add].blt(48+(animation*64),32,wasserfall[add],rect)
                wasserfall[add].blt(48+(animation*64),64,wasserfall[add],rect)
                rect.y += 16
                wasserfall[add].blt(48+(animation*64),80,wasserfall[add],rect)
                wasserfall[add].blt(48+(animation*64),48,wasserfall[add],rect)
                rect.x -= 16
                wasserfall[add].blt(animation*64,80,wasserfall[add],rect)
                wasserfall[add].blt(animation*64,48,wasserfall[add],rect)
     
                #Erstelle Autotile-Mitte
                rect = Rect.new(208+breite*256,(hoehe*96)+(animation*32),32,32)
                wasserfall[add].blt(16+animation*64,32,original.bitmap,rect)
                wasserfall[add].blt(16+animation*64,64,original.bitmap,rect)
     
                #Erstelle Autotile-Ecke
                rect = Rect.new(16+(animation*64),48,32,32)
                wasserfall[add].blt((animation*64)+32,0,wasserfall[add],rect)
               end
            end
          end
        end
     
        #Wandle Wasserfälle zu XP-Autotiles um
        add = 0
        6.times do
          add += 1
          @new_bitmap[add+8] = Sprite.new
          @new_bitmap[add+8].bitmap = Bitmap.new(288,128)
          for x_wert in 0..2
            convert_auto(x_wert*64,0,wasserfall[add])
            rect = Rect.new(32,64,32,32)
            $autotile_bitmap.blt(64,0,$autotile_bitmap,rect)
            @new_bitmap[add+8].bitmap.blt(96*x_wert,0,$autotile_bitmap,ausschnitt)
            $autotile_bitmap.dispose
          end
        end
     
        # KONVERTIERE UNANIMIERTE AUTOTILES
        add = 0
        @new_bitmap[15] = Sprite.new
        @new_bitmap[15].bitmap = Bitmap.new(96,128)
        @new_bitmap[16] = Sprite.new
        @new_bitmap[16].bitmap = Bitmap.new(96,128)
        2.times do
          convert_auto(192,(add*96),original.bitmap)
          add += 1
          ausschnitt = Rect.new(0,0,96,128)
          @new_bitmap[add+14].bitmap.blt(0,0,$autotile_bitmap,ausschnitt)
          $autotile_bitmap.dispose
        end
     
        #Lösche den original-Sprite
        original.dispose
     
        # Speichere die Autotiles
        for save in 1..8
          @new_bitmap[save].bitmap.make_png("#{@ziel} W#{save}")
          @new_bitmap[save].dispose
        end
     
        for save in 9..14
         @new_bitmap[save].bitmap.make_png("#{@ziel} WF#{save-8}")
         @new_bitmap[save].dispose
        end
     
        for save in 15..16
          @new_bitmap[save].bitmap.make_png("#{@ziel} #{save-14}")
          @new_bitmap[save].dispose
        end
      end
     
     
     
      def load_autotile(type)
        # Erstelle original-Sprite
        original = Sprite.new
        # Erstelle original-Bitmap
        original.bitmap = Bitmap.new(@quelle)
        if type == "A1" then
          tileA1
        elsif type == "A2" then
          tileA2
        elsif type == "A3" then
          tileA3
        elsif type == "A4" then
          tileA4
        end
      end
     
      def convert_auto(x,y,bitmap)
        $autotile_bitmap = Bitmap.new(96,128)
     
        rect = Rect.new(x+32,y,32,32)
        $autotile_bitmap.blt(64,0,bitmap,rect)
        rect = Rect.new(x,y,32,32)
        $autotile_bitmap.blt(0,0,bitmap,rect)
     
        rect = Rect.new(x,y+32,16,16)
        $autotile_bitmap.blt(0,32,bitmap,rect)
        rect = Rect.new(x+48,y+32,16,16)
        $autotile_bitmap.blt(80,32,bitmap,rect)
        rect = Rect.new(x,y+80,16,16)
        $autotile_bitmap.blt(0,112,bitmap,rect)
        rect = Rect.new(x+48,y+80,16,16)
        $autotile_bitmap.blt(80,112,bitmap,rect)
     
        rect = Rect.new(x+16,y+32,32,16)
        $autotile_bitmap.blt(16,32,bitmap,rect)
        rect = Rect.new(x,y+48,16,32)
        $autotile_bitmap.blt(0,48,bitmap,rect)
        rect = Rect.new(x+48,y+48,16,32)
        $autotile_bitmap.blt(80,48,bitmap,rect)
        rect = Rect.new(x+16,y+80,32,16)
        $autotile_bitmap.blt(16,112,bitmap,rect)
     
        rect = Rect.new(x+16,y+32,32,16)
        $autotile_bitmap.blt(48,32,bitmap,rect)
        rect = Rect.new(x,y+48,16,32)
        $autotile_bitmap.blt(0,80,bitmap,rect)
        rect = Rect.new(x+48,y+48,16,32)
        $autotile_bitmap.blt(80,80,bitmap,rect)
        rect = Rect.new(x+16,y+80,32,16)
        $autotile_bitmap.blt(48,112,bitmap,rect)
     
        rect = Rect.new(x+16,y+48,32,32)
        $autotile_bitmap.blt(16,48,bitmap,rect)
        rect = Rect.new(x+16,y+48,32,32)
        $autotile_bitmap.blt(16,80,bitmap,rect)
        rect = Rect.new(x+16,y+48,32,32)
        $autotile_bitmap.blt(48,48,bitmap,rect)
        rect = Rect.new(x+16,y+48,32,32)
        $autotile_bitmap.blt(48,80,bitmap,rect)
     
        return $autotile_bitmap
      end
     
      def tileA2
        # Erstelle original-Sprite
        original = Sprite.new
        # Erstelle original-Bitmap
        original.bitmap = Bitmap.new(@quelle)
        # Erstelle neuen Array
        @new_bitmap = Array.new(32)
     
        add = 0
        #Wandle VX-Autotiles in XP-Autotiles
        for breite in 0..7
          for hoehe in 0..3
            add += 1
            @new_bitmap[add] = Sprite.new
            @new_bitmap[add].bitmap = Bitmap.new(96,128)
            convert_auto(breite*64,hoehe*96,original.bitmap)
            rect = Rect.new(0,0,96,128)
            @new_bitmap[add].bitmap.blt(0,0,$autotile_bitmap,rect)
          end
        end
     
        #Lösche den original-Sprite
        original.dispose
     
        #Speichere die Autotiles
        for save in 1..32
          @new_bitmap[save].bitmap.make_png("#{@ziel} - #{save}")
          @new_bitmap[save].dispose
        end
      end
     
      def tileA3
        # Erstelle original-Sprite
        original = Sprite.new
        # Erstelle original-Bitmap
        original.bitmap = Bitmap.new(@quelle)
        # Erstelle neuen Array und neues Bitmap
        @new_bitmap = Array.new(32)
        @tileset = Bitmap.new(256,512)
     
        rect = Rect.new(0,0,256,256)
        @tileset.blt(0,0,original.bitmap,rect)
        rect.x += 256
        @tileset.blt(0,256,original.bitmap,rect)
     
        #Wandle die Tiles in VX-Autotiles
        vxp = Array.new(32)
        add = 0
        for hoehe in 0..3
          for breite in 0..7
            add += 1
            vxp[add] = Bitmap.new(64,96)
            rect = Rect.new(breite*64,hoehe*64,64,64)
            vxp[add].blt(0,32,original.bitmap,rect)
            rect = Rect.new(0,32,16,16)
            vxp[add].blt(0,0,vxp[add],rect)
            rect.x += 32
            vxp[add].blt(16,0,vxp[add],rect)
            rect.y += 32
            vxp[add].blt(16,16,vxp[add],rect)
            rect.x -= 32
            vxp[add].blt(0,16,vxp[add],rect)
          end
        end
     
        # Wandle vxp in XP-Autotiles
        for add in 1..32
          convert_auto(0,0,vxp[add])
          rect = Rect.new(32,64,32,32)
          $autotile_bitmap.blt(64,0,$autotile_bitmap,rect)
          @new_bitmap[add] = Sprite.new
          @new_bitmap[add].bitmap = Bitmap.new(96,128)
          rect = Rect.new(0,0,96,128)
          @new_bitmap[add].bitmap.blt(0,0,$autotile_bitmap,rect)
        end
     
        #Lösche den original-Sprite
        original.dispose
     
        #Speichere die Bitmaps
        for save in 1..32
          @new_bitmap[save].bitmap.make_png("#{@ziel} - #{save}")
          @new_bitmap[save].dispose
        end
     
        @tileset.make_png("Tileset A3")
      end
     
      def tileA4
        # Erstelle original-Sprite
        original = Sprite.new
        # Erstelle original-Bitmap
        original.bitmap = Bitmap.new(@quelle)
        # Erstelle neuen Array und neues Bitmap
        @new_bitmap = Array.new(48)
        for bit in 1..64
          @new_bitmap[bit] = Sprite.new
          @new_bitmap[bit].bitmap = Bitmap.new(96,128)
        end
        @tileset = Bitmap.new(256,768)
     
        #Erstelle die Tiles als komplettes Set
        add = 0
        for br in 0..1
          for he in 0..2
            rect = Rect.new(br*256,(he*160)+32,256,128)
            @tileset.blt(0,add*128,original.bitmap,rect)
            add += 1
          end
        end
      # @tileset.make_png("#{@ziel} Tileset")
      @tileset.dispose
     
        #Konvertiere die bereits fertigen Autotiles
        add = 0
        for breite in 0..7
          for hoehe in 0..2
            add += 1
            convert_auto(breite*64,hoehe*160,original.bitmap)
            rect = Rect.new(0,0,96,128)
            @new_bitmap[add].bitmap.blt(0,0,$autotile_bitmap,rect)
          end
        end
     
        #Wandle die Mauern in VX-Autotiles um
        vxp = Array.new(24)
        add = 0
        for breite in 0..7
          for hoehe in 0..2
            add += 1
            vxp[add] = Bitmap.new(64,96)
            rect = Rect.new(breite*64,(hoehe*160)+96,64,64)
            vxp[add].blt(0,32,original.bitmap,rect)
            rect = Rect.new(0,32,16,16)
            vxp[add].blt(0,0,vxp[add],rect)
            rect.x += 48
            vxp[add].blt(16,0,vxp[add],rect)
            rect.y += 48
            vxp[add].blt(16,16,vxp[add],rect)
            rect.x -= 48
            vxp[add].blt(0,16,vxp[add],rect)
          end
        end
     
        #Wandle die VX-Mauer-Autotiles in XP um
        for add in 1..24
          convert_auto(0,0,vxp[add])
          rect = Rect.new(32,64,32,32)
          $autotile_bitmap.blt(64,0,$autotile_bitmap,rect)
          rect = Rect.new(0,0,96,128)
          @new_bitmap[add+24].bitmap.blt(0,0,$autotile_bitmap,rect)
        end
     
        #Lösche den original-Sprite
        original.dispose
     
        for save in 1..48
          @new_bitmap[save].bitmap.make_png("#{@ziel} - #{save}")
          @new_bitmap[save].dispose
        end
      end
     
      def load_bigchar
        # Erstelle original-Sprite
        original = Sprite.new
        # Erstelle original-Bitmap
        original.bitmap = Bitmap.new(@quelle)
        #Lese Breite und Höhe
        breite = original.bitmap.width
        hoehe = original.bitmap.height
        #Erstelle neues Bitmap
        @new_bitmap = Sprite.new
        @new_bitmap.bitmap = Bitmap.new(breite+breite/3,hoehe)
     
        rect = Rect.new(0,0,breite,hoehe)
        @new_bitmap.bitmap.blt(breite/3,0,original.bitmap,rect)
        rect = Rect.new(breite/3,0,breite/3,hoehe)
        @new_bitmap.bitmap.blt(0,0,original.bitmap,rect)
     
        #Lösche den original-Sprite
        original.dispose
        #Speichere die Bitmaps
        @new_bitmap.bitmap.make_png("#{@ziel}")
        @new_bitmap.dispose
      end
    end
    
    class Extras
      def initialize(quelle,ziel,type,shutdown=false)
        @quelle = quelle
        @ziel = ziel
     
        # Führe entsprechende Methode aus
        if type == "Tilefusion" then
          load_tilefusion
        elsif type == "Autofusion" then
          load_autofusion
        end
     
        # Wenn shutdown true ist, beende das Programm
        if shutdown == true then
          $scene = nil
        end
      end
     
      def load_tilefusion
        #Lade die Tilesets
        hoehe = 0
        for load in 0..@quelle.size-1
          @quelle[load] = Bitmap.new(@quelle[load])
          hoehe += @quelle[load].height
        end
        #Erstelle ein neues Bitmap
        @new_bitmap = Bitmap.new(256,hoehe)
        #Fusioniere die Tilesets
        hoehe = 0
        for fus in 0..@quelle.size-1
          rect = Rect.new(0,0,256,@quelle[fus].height)
          @new_bitmap.blt(0,hoehe,@quelle[fus],rect)
          hoehe += @quelle[fus].height
        end
        #Speichere das Tileset
        @new_bitmap.make_png("#{@ziel}")
      end
     
      def load_autofusion
        #Lade die beiden Bilder
        for load in [0,1]
          @quelle[load] = Bitmap.new(@quelle[load])
        end
        #Wenn eins der beiden ein einziges Tile ist, wandle es um
        for load in [0,1]
          if @quelle[load].width == 32 and @quelle[load].height == 32 then
            temp = Bitmap.new(32,32)
            rect = Rect.new(0,0,32,32)
            temp.blt(0,0,@quelle[load],rect)
            @quelle[load] = Bitmap.new(96,128)
            @quelle[load].blt(0,0,temp,rect)
            @quelle[load].blt(64,0,temp,rect)
            for h in 1..3
              for b in 0..2
                @quelle[load].blt(b*32,h*32,temp,rect)
              end
            end
          end
        end
     
        #Lege das zweite Autotile über das erste
        rect = Rect.new(0,0,96,128)
        @quelle[0].blt(0,0,@quelle[1],rect)
        #Speichere das Bitmap
        @quelle[0].make_png("#{@ziel}")
      end
    end


    Вызов скрипта

    $vxtoxp = VX_to_XP.new("Actor1","Actor1","Faces")

    Источник тут http://www.rpg-studio.de/script/vx-x...rter-5636.html
    Последний раз редактировалось Bullet S.D.; 07.06.2011 в 00:45.
    Спойлер Проекты Dark Rise INC.:

Информация о теме

Пользователи, просматривающие эту тему

Эту тему просматривают: 1 (пользователей: 0 , гостей: 1)

Социальные закладки

Социальные закладки

Ваши права

  • Вы не можете создавать новые темы
  • Вы не можете отвечать в темах
  • Вы не можете прикреплять вложения
  • Вы не можете редактировать свои сообщения
  •