[Ayene]

~ Skrypt z biblioteką TRGSSX.dll ~

Krótki opis
Dodatek do skryptu "Rozszerzone okno statusu". Skrypt powiększa możliwości graficzne RPG Makera VX. Należy go umieścić na takich samych zasadach jak inne skrypty.

Autor skryptu
KGC

Tłumaczenie i przeróbki
Ayene [yurika@o2.pl]

Kompatybilność
Tylko VX.

UWAGA!!!
Do prawidłowego działania wymagane jest umieszczenie w folderze z grą biblioteki 'TRGSSX.dll'. Do ściągnięcia w załączniku

Skrypt

Spoiler: Kod: # ========================================================== #                        ~ Rozszerzona bitmapa ~ #                       Data publikacji: 11.10.2009 #                               Autor: KGC #               Tłumaczenie i poprawki: Ayene [yurika@o2.pl] #          Zapraszam na stronę UltimaForum - http://www.ultimateam.pl # ========================================================== # Instalacja: Umieść ten skrypt nad Main w Edytorze Skryptu. # Do poprawnego działania wymagane jest umieszczenie w folderze z grą biblioteki # TRGSSX.dll. Dostępna jest na stronie www.ultimateam.pl # ========================================================== # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # --------------------------- POCZĄTEK SKRYPTU --------------------------------- module KGC module BitmapExtension # ---------------------------- POCZĄTEK EDYCJI ---------------------------------      # Tryb wydajności draw_text   #   0 : draw_text (domyślny)   #   1 : draw_text_na   #   2 : draw_text_fast   DEFAULT_MODE = 2   # Nazwa domyślnej czcionki dla każdego z trybów   #   ["czcionka 1", "czcionka 2", ...],   DEFAULT_FONT_NAME = [      Font.default_name,  # 0     ["Verdana"],  # 1     ["Comic Sans MS"],  # 2   ]   DEFAULT_FRAME = true   DEFAULT_GRAD_COLOR = nil   # ----------------------------- KONIEC EDYCJI ----------------------------------      end end # -----------NIE EDYTUJ PONIŻEJ, CHYBA ŻE WIESZ CO ROBISZ ^^-------------------- $imported = {} if $imported == nil $imported["BitmapExtension"] = true #============================================================================== # &#9633; TRGSSX #------------------------------------------------------------------------------ #  Wgranie biblioteki "TRGSSX.dll" #============================================================================== module TRGSSX   # Mieszanie   BLEND_NORMAL  = 0  # Normalne   BLEND_ADD     = 1  # Dodawanie   BLEND_SUB     = 2  # Odejmowanie   BLEND_MUL     = 3  # Mnożenie   BLEND_HILIGHT = 4    # Kody operacji   SRCCOPY     = 0x00CC0020  # dest = src   SRCPAINT    = 0x00EE0086  # dest = dest | src   SRCAND      = 0x008800C6  # dest = dest & src   SRCINVERT   = 0x00660046  # dest = dest ^ src   SRCERASE    = 0x00440328  # dest = dest & ~src   NOTSRCCOPY  = 0x00330008  # dest = ~src   NOTSRCERASE = 0x001100A6  # dest = ~(dest | src) = ~dest & ~src   # Metoda wstawiania   IM_INVALID             = -1   IM_DEFAULT             = 0   IM_LOWQUALITY          = 1   IM_HIGHQUALITY         = 2   IM_BILINEAR            = 3   IM_BICUBIC             = 4   IM_NEARESTNEIGHBOR     = 5   IM_HIGHQUALITYBILINEAR = 6   IM_HIGHQUALITYBICUBIC  = 7   # Wygładzanie   SM_INVALID     = -1   SM_DEFAULT     = 0   SM_HIGHSPEED   = 1   SM_HIGHQUALITY = 2   SM_NONE        = 3   SM_ANTIALIAS   = 4   # Wypełnianie   FM_FIT    = 0  # takie jak kształt   FM_CIRCLE = 1  # okrąg   # Styl czcionki   FS_BOLD      = 0x0001  # Pogrubienie   FS_ITALIC    = 0x0002  # Kursywa   FS_UNDERLINE = 0x0004  # Podkreślenie   FS_STRIKEOUT = 0x0008  # Przekreślenie   FS_SHADOW    = 0x0010  # Cień   FS_FRAME     = 0x0020  # Ramka   DLL_NAME = 'TRGSSX' # Nazwa biblioteki   begin     NO_TRGSSX = false     unless defined?(@@_trgssx_version)       @@_trgssx_version =         Win32API.new(DLL_NAME, 'DllGetVersion', 'v', 'l')       @@_trgssx_get_interpolation_mode =         Win32API.new(DLL_NAME, 'GetInterpolationMode', 'v', 'l')       @@_trgssx_set_interpolation_mode =         Win32API.new(DLL_NAME, 'SetInterpolationMode', 'l', 'v')       @@_trgssx_get_smoothing_mode =         Win32API.new(DLL_NAME, 'GetSmoothingMode', 'v', 'l')       @@_trgssx_set_smoothing_mode =         Win32API.new(DLL_NAME, 'SetSmoothingMode', 'l', 'v')       @@_trgssx_rop_blt =         Win32API.new(DLL_NAME, 'RopBlt', 'pllllplll', 'l')       @@_trgssx_clip_blt =         Win32API.new(DLL_NAME, 'ClipBlt', 'pllllplll', 'l')       @@_trgssx_blend_blt =         Win32API.new(DLL_NAME, 'BlendBlt', 'pllllplll', 'l')       @@_trgssx_stretch_blt_r =         Win32API.new(DLL_NAME, 'StretchBltR', 'pllllplllll', 'l')       @@_trgssx_skew_blt_r =         Win32API.new(DLL_NAME, 'SkewBltR', 'pllpllllll', 'l')       @@_trgssx_draw_polygon =         Win32API.new(DLL_NAME, 'DrawPolygon', 'pplll', 'l')       @@_trgssx_fill_polygon =         Win32API.new(DLL_NAME, 'FillPolygon', 'ppllll', 'l')       @@_trgssx_draw_regular_polygon =         Win32API.new(DLL_NAME, 'DrawRegularPolygon', 'pllllll', 'l')       @@_trgssx_fill_regular_polygon =         Win32API.new(DLL_NAME, 'FillRegularPolygon', 'plllllll', 'l')       @@_trgssx_draw_spoke =         Win32API.new(DLL_NAME, 'DrawSpoke', 'pllllll', 'l')       @@_trgssx_draw_text_na =         Win32API.new(DLL_NAME, 'DrawTextNAA', 'pllllpplpll', 'l')       @@_trgssx_draw_text_fast =         Win32API.new(DLL_NAME, 'DrawTextFastA', 'pllllpplpll', 'l')       @@_trgssx_get_text_size_na =         Win32API.new(DLL_NAME, 'GetTextSizeNAA', 'pppllp', 'l')       @@_trgssx_get_text_size_fast =         Win32API.new(DLL_NAME, 'GetTextSizeFastA', 'pppllp', 'l')       @@_trgssx_save_to_bitmap =         Win32API.new(DLL_NAME, 'SaveToBitmapA', 'pp', 'l')     end   rescue     NO_TRGSSX = true     print "Brakuje biblioteki - \"#{DLL_NAME}.dll\". " +     "Możesz ją pobrać ze strony: www.ultimateam.pl"     exit   end   module_function   #--------------------------------------------------------------------------   # Wersja 1.23 &#8594; 123   #--------------------------------------------------------------------------   def version     return -1 if NO_TRGSSX     return @@_trgssx_version.call   end   #--------------------------------------------------------------------------   # GetInterpolationMode   #--------------------------------------------------------------------------   def get_interpolation_mode     return @@_trgssx_get_interpolation_mode.call   end   #--------------------------------------------------------------------------   # SetInterpolationMode   #--------------------------------------------------------------------------   def set_interpolation_mode(mode)     @@_trgssx_set_interpolation_mode.call(mode)   end   #--------------------------------------------------------------------------   # GetSmoothingMode   #--------------------------------------------------------------------------   def get_smoothing_mode     return @@_trgssx_get_smoothing_mode.call   end   #--------------------------------------------------------------------------   # SetSmoothingMode   #--------------------------------------------------------------------------   def set_smoothing_mode(mode)     @@_trgssx_set_smoothing_mode.call(mode)   end   #--------------------------------------------------------------------------   # BitBltRop   #--------------------------------------------------------------------------   def rop_blt(dest_info, dx, dy, dw, dh, src_info, sx, sy, rop)     return @@_trgssx_rop_blt.call(dest_info, dx, dy, dw, dh,       src_info, sx, sy, rop)   end   #--------------------------------------------------------------------------   # ClipBlt   #--------------------------------------------------------------------------   def clip_blt(dest_info, dx, dy, dw, dh, src_info, sx, sy, hRgn)     return @@_trgssx_clip_blt.call(dest_info, dx, dy, dw, dh,       src_info, sx, sy, hRgn)   end   #--------------------------------------------------------------------------   # BlendBlt   #--------------------------------------------------------------------------   def blend_blt(dest_info, dx, dy, dw, dh, src_info, sx, sy, blend)     return @@_trgssx_blend_blt.call(dest_info, dx, dy, dw, dh,       src_info, sx, sy, blend)   end   #--------------------------------------------------------------------------   # StretchBltR   #--------------------------------------------------------------------------   def stretch_blt_r(dest_info, dx, dy, dw, dh, src_info, sx, sy, sw, sh, op)     return @@_trgssx_stretch_blt_r.call(dest_info, dx, dy, dw, dh,       src_info, sx, sy, sw, sh, op)   end   #--------------------------------------------------------------------------   # SkewBltR   #--------------------------------------------------------------------------   def skew_blt_r(dest_info, dx, dy, src_info, sx, sy, sw, sh, slope, op)     return @@_trgssx_skew_blt_r.call(dest_info, dx, dy,       src_info, sx, sy, sw, sh, slope, op)   end   #--------------------------------------------------------------------------   # DrawPolygon   #--------------------------------------------------------------------------   def draw_polygon(dest_info, pts, n, color, width)     return @@_trgssx_draw_polygon.call(dest_info, pts,       n, color, width)   end   #--------------------------------------------------------------------------   # FillPolygon   #--------------------------------------------------------------------------   def fill_polygon(dest_info, pts, n, st_color, ed_color, fm)     return @@_trgssx_fill_polygon.call(dest_info, pts,       n, st_color, ed_color, fm)   end   #--------------------------------------------------------------------------   # DrawRegularPolygon   #--------------------------------------------------------------------------   def draw_regular_polygon(dest_info, dx, dy, r, n, color, width)     return @@_trgssx_draw_regular_polygon.call(dest_info, dx, dy,       r, n, color, width)   end   #--------------------------------------------------------------------------   # FillRegularPolygon   #--------------------------------------------------------------------------   def fill_regular_polygon(dest_info, dx, dy, r, n, st_color, ed_color, fm)     return @@_trgssx_fill_regular_polygon.call(dest_info, dx, dy,       r, n, st_color, ed_color, fm)   end   #--------------------------------------------------------------------------   # DrawSpoke   #--------------------------------------------------------------------------   def draw_spoke(dest_info, dx, dy, r, n, color, width)     return @@_trgssx_draw_spoke.call(dest_info, dx, dy,       r, n, color, width)   end   #--------------------------------------------------------------------------   # DrawTextNAA   #--------------------------------------------------------------------------   def draw_text_na(dest_info, dx, dy, dw, dh, text,       fontname, fontsize, color, align, flags)     return @@_trgssx_draw_text_na.call(dest_info, dx, dy, dw, dh, text.dup,       fontname, fontsize, color, align, flags)   end   #--------------------------------------------------------------------------   # DrawTextFastA   #--------------------------------------------------------------------------   def draw_text_fast(dest_info, dx, dy, dw, dh, text,       fontname, fontsize, color, align, flags)     return @@_trgssx_draw_text_fast.call(dest_info, dx, dy, dw, dh, text.dup,       fontname, fontsize, color, align, flags)   end   #--------------------------------------------------------------------------   # GetTextSizeNAA   #--------------------------------------------------------------------------   def get_text_size_na(dest_info, text, fontname, fontsize, flags, size)     return @@_trgssx_get_text_size_na.call(dest_info, text,       fontname, fontsize, flags, size)   end   #--------------------------------------------------------------------------   # GetTextSizeFastA   #--------------------------------------------------------------------------   def get_text_size_fast(dest_info, text, fontname, fontsize, flags, size)     return @@_trgssx_get_text_size_fast.call(dest_info, text,       fontname, fontsize, flags, size)   end   #--------------------------------------------------------------------------   # SaveToBitmapA   #--------------------------------------------------------------------------   def save_to_bitmap(filename, info)     return @@_trgssx_save_to_bitmap.call(filename, info)   end end #============================================================================== # Bitmap #============================================================================== class Bitmap   #--------------------------------------------------------------------------   # Tryb wstawiania (interpolacji)   #--------------------------------------------------------------------------   def self.interpolation_mode     return -1 if TRGSSX::NO_TRGSSX     return TRGSSX.get_interpolation_mode   end   #--------------------------------------------------------------------------   # Ustawienia trybu wstawiania   #--------------------------------------------------------------------------   def self.interpolation_mode=(value)     return if TRGSSX::NO_TRGSSX     TRGSSX.set_interpolation_mode(value)   end   #--------------------------------------------------------------------------   # Tryb wygładzania   #--------------------------------------------------------------------------   def self.smoothing_mode     return -1 if TRGSSX::NO_TRGSSX     return TRGSSX.get_smoothing_mode   end   #--------------------------------------------------------------------------   # Wygładzanie   #--------------------------------------------------------------------------   def self.smoothing_mode=(value)     return if TRGSSX::NO_TRGSSX     TRGSSX.set_smoothing_mode(value)   end   #--------------------------------------------------------------------------   # Info o bimapie (object_id, width, height)   #--------------------------------------------------------------------------   def get_base_info     return [object_id, width, height].pack('l!3')   end   #--------------------------------------------------------------------------   # Operacje rastrowe   #--------------------------------------------------------------------------   def rop_blt(x, y, src_bitmap, src_rect, rop = TRGSSX::SRCCOPY)     return -1 if TRGSSX::NO_TRGSSX     return TRGSSX.rop_blt(get_base_info,       x, y, src_rect.width, src_rect.height,       src_bitmap.get_base_info, src_rect.x, src_rect.y, rop)   end   #--------------------------------------------------------------------------   # Bitmapa klipu   #--------------------------------------------------------------------------   def clip_blt(x, y, src_bitmap, src_rect, region)     return -1 if TRGSSX::NO_TRGSSX     hRgn = region.create_region_handle     return if hRgn == nil || hRgn == 0     result = TRGSSX.clip_blt(get_base_info,       x, y, src_rect.width, src_rect.height,       src_bitmap.get_base_info, src_rect.x, src_rect.y, hRgn)         Region.delete_region_handles     return result   end   #--------------------------------------------------------------------------   # Bitmapa mieszania   #--------------------------------------------------------------------------   def blend_blt(x, y, src_bitmap, src_rect, blend = TRGSSX::BLEND_NORMAL)     return -1 if TRGSSX::NO_TRGSSX     return TRGSSX.blend_blt(get_base_info,       x, y, src_rect.width, src_rect.height,       src_bitmap.get_base_info, src_rect.x, src_rect.y, blend)   end   #--------------------------------------------------------------------------   #   #--------------------------------------------------------------------------   def stretch_blt_r(dest_rect, src_bitmap, src_rect, opacity = 255)     return -1 if TRGSSX::NO_TRGSSX     return TRGSSX.stretch_blt_r(get_base_info,       dest_rect.x, dest_rect.y, dest_rect.width, dest_rect.height,       src_bitmap.get_base_info,       src_rect.x, src_rect.y, src_rect.width, src_rect.height,       opacity)   end   #--------------------------------------------------------------------------   #   #--------------------------------------------------------------------------   def skew_blt(x, y, src_bitmap, src_rect, slope, opacity = 255)     slope = [[slope, -89].max, 89].min     sh    = src_rect.height     off  = sh / Math.tan(Math::PI * (90 - slope.abs) / 180.0)     if slope >= 0       dx   = x + off.to_i       diff = -off / sh     else       dx   = x       diff = off / sh     end     rect = Rect.new(src_rect.x, src_rect.y, src_rect.width, 1)     sh.times { |i|       blt(dx + (diff * i).round, y + i, src_bitmap, rect, opacity)       rect.y += 1     }   end   #--------------------------------------------------------------------------   #   #--------------------------------------------------------------------------   def skew_blt_r(x, y, src_bitmap, src_rect, slope, opacity = 255)     return -1 if TRGSSX::NO_TRGSSX     return TRGSSX.skew_blt_r(get_base_info,       x, y, src_bitmap.get_base_info,       src_rect.x, src_rect.y, src_rect.width, src_rect.height,       slope, opacity)   end   #--------------------------------------------------------------------------   # Rysowanie wielokąta   #--------------------------------------------------------------------------   def draw_polygon(points, color, width = 1)     return -1 if TRGSSX::NO_TRGSSX     _points = create_point_pack(points)     return TRGSSX.draw_polygon(get_base_info,       _points, points.size, color.argb_code, width)   end   #--------------------------------------------------------------------------   # Wypełnianie wielokąta   #--------------------------------------------------------------------------   def fill_polygon(points, st_color, ed_color, fill_mode = TRGSSX::FM_FIT)     return -1 if TRGSSX::NO_TRGSSX     _points = create_point_pack(points)     return TRGSSX.fill_polygon(get_base_info,       _points, points.size, st_color.argb_code, ed_color.argb_code, fill_mode)   end   #--------------------------------------------------------------------------   # Tworzenie listy współrzędnych   #--------------------------------------------------------------------------   def create_point_pack(points)     result = ''     points.each { |pt| result += pt.pack('l!2') }     return result   end   private :create_point_pack   #--------------------------------------------------------------------------   # Rysowanie wielokąta foremnego   #--------------------------------------------------------------------------   def draw_regular_polygon(x, y, r, n, color, width = 1)     return -1 if TRGSSX::NO_TRGSSX     return TRGSSX.draw_regular_polygon(get_base_info,       x, y, r, n, color.argb_code, width)   end   #--------------------------------------------------------------------------   # Wypełnianie wielokąta foremnego   #--------------------------------------------------------------------------   def fill_regular_polygon(x, y, r, n, st_color, ed_color,       fill_mode = TRGSSX::FM_FIT)     return -1 if TRGSSX::NO_TRGSSX     return TRGSSX.fill_regular_polygon(get_base_info,       x, y, r, n, st_color.argb_code, ed_color.argb_code, fill_mode)   end   #--------------------------------------------------------------------------   # Elementy koła   #--------------------------------------------------------------------------   def draw_spoke(x, y, r, n, color, width = 1)     return -1 if TRGSSX::NO_TRGSSX     return TRGSSX.draw_spoke(get_base_info,       x, y, r, n, color.argb_code, width)   end   #--------------------------------------------------------------------------   # Wygładzanie tekstu 'na'   #--------------------------------------------------------------------------   def draw_text_na(*args)     return -1 if TRGSSX::NO_TRGSSX     x, y, width, height, text, align = get_text_args(args)     fname = get_available_font_name     flags = get_draw_text_flags     return TRGSSX.draw_text_na(get_base_info, x, y, width, height, text,       fname, font.size, get_text_color, align, flags)   end   #--------------------------------------------------------------------------   # Renderowanie tekstu 'fast'   #--------------------------------------------------------------------------   def draw_text_fast(*args)     return -1 if TRGSSX::NO_TRGSSX     x, y, width, height, text, align = get_text_args(args)     fname = get_available_font_name     flags = get_draw_text_flags     return TRGSSX.draw_text_fast(get_base_info, x, y, width, height, text,       fname, font.size, get_text_color, align, flags)   end   #--------------------------------------------------------------------------   # Wielkość tekstu 'na'   #--------------------------------------------------------------------------   def text_size_na(text)     return -1 if TRGSSX::NO_TRGSSX     fname = get_available_font_name     flags = get_draw_text_flags     size  = [0, 0].pack('l!2')     result = TRGSSX.get_text_size_na(get_base_info, text.to_s,       fname, font.size, flags, size)     size = size.unpack('l!2')     rect = Rect.new(0, 0, size[0], size[1])     return rect   end   #--------------------------------------------------------------------------   # Wielkość tekstu 'fast'   #--------------------------------------------------------------------------   def text_size_fast(text)     return -1 if TRGSSX::NO_TRGSSX     fname = get_available_font_name     flags = get_draw_text_flags     size  = [0, 0].pack('l!2')     result = TRGSSX.get_text_size_fast(get_base_info, text.to_s,       fname, font.size, flags, size)     size = size.unpack('l!2')     rect = Rect.new(0, 0, size[0], size[1])     return rect   end   #--------------------------------------------------------------------------   # Argumenty   #--------------------------------------------------------------------------   def get_text_args(args)     if args[0].is_a?(Rect)           if args.size.between?(2, 4)         x, y = args[0].x, args[0].y         width, height = args[0].width, args[0].height         text  = args[1].to_s         align = (args[2].equal?(nil) ? 0 : args[2])       else         raise(ArgumentError,           "wrong number of arguments(#{args.size} of #{args.size < 2 ? 2 : 4})")         return       end     else             if args.size.between?(5, 7)         x, y, width, height = args         text  = args[4].to_s         align = (args[5].equal?(nil) ? 0 : args[5])       else         raise(ArgumentError,           "wrong number of arguments(#{args.size} of #{args.size < 5 ? 5 : 7})")         return       end     end     return [x, y, width, height, text, align]   end   private :get_text_args   #--------------------------------------------------------------------------   # Pobranie dostępnej czcionki   #--------------------------------------------------------------------------   def get_available_font_name     if font.name.is_a?(Array)       font.name.each { |f|         return f if Font.exist?(f)       }       return nil     else       return font.name     end   end   private :get_available_font_name   #--------------------------------------------------------------------------   # Kolor tekstu (main, gradation, shadow, needGrad)   #--------------------------------------------------------------------------   def get_text_color     need_grad = !font.gradation_color.equal?(nil)     result = []     result << font.color.argb_code     result << (need_grad ? font.gradation_color.argb_code : 0)     result << 0xFF000000     result << (need_grad ? 1 : 0)     return result.pack('l!4')   end   private :get_text_color   #--------------------------------------------------------------------------   # Formatowanie tekstu   #--------------------------------------------------------------------------   def get_draw_text_flags     flags  = 0     flags |= TRGSSX::FS_BOLD   if font.bold     flags |= TRGSSX::FS_ITALIC if font.italic     flags |= TRGSSX::FS_SHADOW if font.shadow && !font.frame     flags |= TRGSSX::FS_FRAME  if font.frame     return flags   end   private :get_draw_text_flags   #--------------------------------------------------------------------------   # Zapis   #--------------------------------------------------------------------------   def save(filename)     return -1 if TRGSSX::NO_TRGSSX     return TRGSSX.save_to_bitmap(filename, get_base_info)   end end #============================================================================== # Kolor #============================================================================== class Color   #--------------------------------------------------------------------------   # Kolory RGB   #--------------------------------------------------------------------------   def argb_code     n  = 0     n |= alpha.to_i << 24     n |= red.to_i   << 16     n |= green.to_i <<  8     n |= blue.to_i     return n   end end #============================================================================== # Czcionka #============================================================================== class Font   unless const_defined?(:XP_MODE)         unless method_defined?(:shadow)       XP_MODE = true       @@default_shadow = false       attr_writer :shadow       def self.default_shadow         return @@default_shadow       end       def self.default_shadow=(s)         @@default_shadow = s       end       def shadow         return (@shadow == nil ? @@default_shadow : @shadow)       end     else       XP_MODE = false     end   end   #--------------------------------------------------------------------------   # Zmienna klasa   #--------------------------------------------------------------------------   @@default_frame           = KGC::BitmapExtension::DEFAULT_FRAME   @@default_gradation_color = KGC::BitmapExtension::DEFAULT_GRAD_COLOR   #--------------------------------------------------------------------------   # Zmienne   #--------------------------------------------------------------------------   attr_accessor :gradation_color   #--------------------------------------------------------------------------   # Rozpoczęcie   #--------------------------------------------------------------------------   unless private_method_defined?(:initialize_KGC_BitmapExtension)     alias initialize_KGC_BitmapExtension initialize   end   def initialize(name = Font.default_name, size = Font.default_size)     initialize_KGC_BitmapExtension(name, size)     @frame = nil     @gradation_color = @@default_gradation_color     if XP_MODE       @shadow = nil     end   end   #--------------------------------------------------------------------------   # Domyślna grafika   #--------------------------------------------------------------------------   def self.default_frame     return @@default_frame   end   #--------------------------------------------------------------------------   #   #--------------------------------------------------------------------------   def self.default_frame=(value)     @@default_frame = value   end   #--------------------------------------------------------------------------   # Domyślny kolor gradientu   #--------------------------------------------------------------------------   def self.default_gradation_color     return @@default_gradation_color   end   #--------------------------------------------------------------------------   #   #--------------------------------------------------------------------------   def self.default_gradation_color=(value)     @@default_gradation_color = value   end   #--------------------------------------------------------------------------   # Cień   #--------------------------------------------------------------------------   unless method_defined?(:shadow_eq) || XP_MODE     alias shadow_eq shadow=   end   def shadow=(value)     XP_MODE ? @shadow = value : shadow_eq(value)   end   #--------------------------------------------------------------------------   #   #--------------------------------------------------------------------------   def frame     return (@frame == nil ? @@default_frame : @frame)   end   #--------------------------------------------------------------------------   #   #--------------------------------------------------------------------------   def frame=(value)     @frame = value   end end #============================================================================== # Region #============================================================================== class Region   #--------------------------------------------------------------------------   # Zmienna klasy   #--------------------------------------------------------------------------   @@handles = []    #--------------------------------------------------------------------------   # Win32API   #--------------------------------------------------------------------------   @@_api_delete_object = Win32API.new('gdi32', 'DeleteObject', 'l', 'l')   #--------------------------------------------------------------------------   # Tworzenie kształtu   #--------------------------------------------------------------------------   def create_region_handle    return 0   end   #--------------------------------------------------------------------------   # AND (&)   #--------------------------------------------------------------------------   def &(obj)     return nil unless obj.is_a?(Region)     return CombinedRegion.new(CombinedRegion::RGN_AND, self, obj)   end   #--------------------------------------------------------------------------   # AND (*)   #--------------------------------------------------------------------------   def *(obj)     return self.&(obj)   end   #--------------------------------------------------------------------------   # OR (|)   #--------------------------------------------------------------------------   def |(obj)     return nil unless obj.is_a?(Region)     return CombinedRegion.new(CombinedRegion::RGN_OR, self, obj)   end   #--------------------------------------------------------------------------   # OR (+)   #--------------------------------------------------------------------------   def +(obj)     return self.|(obj)   end   #--------------------------------------------------------------------------   # XOR (^)   #--------------------------------------------------------------------------   def ^(obj)     return nil unless obj.is_a?(Region)     return CombinedRegion.new(CombinedRegion::RGN_XOR, self, obj)   end   #--------------------------------------------------------------------------   # DIFF (-)   #--------------------------------------------------------------------------   def -(obj)     return nil unless obj.is_a?(Region)     return CombinedRegion.new(CombinedRegion::RGN_DIFF, self, obj)   end   #--------------------------------------------------------------------------   #   #--------------------------------------------------------------------------   def self.delete_region_handles     @@handles.uniq!     @@handles.each { |h| @@_api_delete_object.call(h) }     @@handles.clear   end end #============================================================================== # RectRegion #============================================================================== class RectRegion < Region   #--------------------------------------------------------------------------   # Zmienne   #--------------------------------------------------------------------------   attr_accessor :x                  attr_accessor :y                  attr_accessor :width              attr_accessor :height            #--------------------------------------------------------------------------   # Win32API   #--------------------------------------------------------------------------   @@_api_create_rect_rgn = Win32API.new('gdi32',     'CreateRectRgn', 'llll', 'l')   @@_api_create_rect_rgn_indirect = Win32API.new('gdi32',     'CreateRectRgnIndirect', 'l', 'l')   #--------------------------------------------------------------------------   # Rozpoczęcie   #--------------------------------------------------------------------------   def initialize(*args)     if args[0].is_a?(Rect)       rect = args[0]       @x = rect.x       @y = rect.y       @width  = rect.width       @height = rect.height     else       @x, @y, @width, @height = args     end   end   #--------------------------------------------------------------------------   # Tworzenie kształtu   #--------------------------------------------------------------------------   def create_region_handle     hRgn = @@_api_create_rect_rgn.call(@x, @y, @x + @width, @y + @height)     @@handles << hRgn     return hRgn   end end #============================================================================== # RoundRectRegion #============================================================================== class RoundRectRegion < RectRegion   #--------------------------------------------------------------------------   # Zmienne   #--------------------------------------------------------------------------   attr_accessor :width_ellipse      attr_accessor :height_ellipse    #--------------------------------------------------------------------------   # Win32API   #--------------------------------------------------------------------------   @@_api_create_round_rect_rgn = Win32API.new('gdi32',     'CreateRoundRectRgn', 'llllll', 'l')   #--------------------------------------------------------------------------   # Rozpoczęcie   #--------------------------------------------------------------------------   def initialize(*args)     super     if args[0].is_a?(Rect)       @width_ellipse  = args[1]       @height_ellipse = args[2]     else       @width_ellipse  = args[4]       @height_ellipse = args[5]     end   end   #--------------------------------------------------------------------------   # Tworzenie kształtu   #--------------------------------------------------------------------------   def create_region_handle     hRgn = @@_api_create_round_rect_rgn.call(@x, @y, @x + @width, @y + @height,       width_ellipse, height_ellipse)     @@handles << hRgn     return hRgn   end end #============================================================================== # EllipticRegion #============================================================================== class EllipticRegion < RectRegion   #--------------------------------------------------------------------------   # Win32API   #--------------------------------------------------------------------------   @@_api_create_elliptic_rgn = Win32API.new('gdi32',     'CreateEllipticRgn', 'llll', 'l')   @@_api_create_elliptic_rgn_indirect = Win32API.new('gdi32',     'CreateEllipticRgnIndirect', 'l', 'l')   #--------------------------------------------------------------------------   # Tworznenie kształtu   #--------------------------------------------------------------------------   def create_region_handle     hRgn = @@_api_create_elliptic_rgn.call(@x, @y, @x + @width, @y + @height)     @@handles << hRgn     return hRgn   end end #============================================================================== # CircularRegion #============================================================================== class CircularRegion < EllipticRegion   #--------------------------------------------------------------------------   # Zmienne   #--------------------------------------------------------------------------   attr_reader   :radius    #--------------------------------------------------------------------------   # Rozpoczęcie   #--------------------------------------------------------------------------   def initialize(x, y, r)     @cx = x     @cy = y     self.radius = r     super(@cx - r, @cy - r, r * 2, r * 2)   end   #--------------------------------------------------------------------------   # Parametr x   #--------------------------------------------------------------------------   def x     return @cx   end   #--------------------------------------------------------------------------   # Parametr y   #--------------------------------------------------------------------------   def y     return @cy   end   #--------------------------------------------------------------------------   # Zmiana parametru x   #--------------------------------------------------------------------------   def x=(value)     @cx = value     @x = @cx - @radius   end   #--------------------------------------------------------------------------   # Zmiana parametru y   #--------------------------------------------------------------------------   def y=(value)     @cy = value     @y = @cy - @radius   end   #--------------------------------------------------------------------------   # Radiany   #--------------------------------------------------------------------------   def radius=(value)     @radius = value     @x = @cx - @radius     @y = @cy - @radius     @width = @height = @radius * 2   end end #============================================================================== # PolygonRegion #============================================================================== class PolygonRegion < Region   #--------------------------------------------------------------------------   # Stała   #--------------------------------------------------------------------------   # Wypełnienie wielokąta   ALTERNATE = 1  # Tryb alternatywny   WINDING   = 2  # Tryb kręty   #--------------------------------------------------------------------------   # Zmienne   #--------------------------------------------------------------------------   attr_accessor :points        attr_accessor :fill_mode    #--------------------------------------------------------------------------   # Win32API   #--------------------------------------------------------------------------   @@_api_create_polygon_rgn = Win32API.new('gdi32',     'CreatePolygonRgn', 'pll', 'l')   @@_api_create_polypolygon_rgn = Win32API.new('gdi32',     'CreatePolyPolygonRgn', 'llll', 'l')   #--------------------------------------------------------------------------   # Rozpoczęcie   #--------------------------------------------------------------------------   def initialize(*points)     @points = points      @fill_mode = WINDING   end   #--------------------------------------------------------------------------   # Tworzenie kształtu   #--------------------------------------------------------------------------   def create_region_handle     pts = ""     points.each { |pt| pts += pt.pack("ll") }     hRgn = @@_api_create_polygon_rgn.call(pts, points.size, fill_mode)     @@handles << hRgn     return hRgn   end end #============================================================================== # StarRegion #============================================================================== class StarRegion < PolygonRegion   #--------------------------------------------------------------------------   # Stałe   #--------------------------------------------------------------------------   POINT_NUM = 5               # Wyniki   PI_4      = 4.0 * Math::PI  # 4 * Pi   #--------------------------------------------------------------------------   # Zmienne   #--------------------------------------------------------------------------   attr_reader   :x                  attr_reader   :y                  attr_reader   :width              attr_reader   :height            attr_reader   :angle              #--------------------------------------------------------------------------   # Rozpoczęcie   #--------------------------------------------------------------------------   def initialize(*args)     super()     shape = args[0]     ang = args[1]     case shape     when CircularRegion       @x = shape.x - shape.radius       @y = shape.y - shape.radius       @width = @height = shape.radius * 2     when Rect, RectRegion, EllipticRegion       @x = shape.x       @y = shape.y       @width  = shape.width       @height = shape.height     when Integer       @x, @y, @width, @height = args       ang = args[4]     else       @x = @y = @width = @height = 0     end     @angle = (ang == nil ? 0 : ang % 360)     @__init = true     @points = create_star_points   end   #--------------------------------------------------------------------------   # Tworzenie ramion gwiazdy   #--------------------------------------------------------------------------   def create_star_points     return unless @__init     dw = (width + 1) / 2     dh = (height + 1) / 2     dx = x + dw     dy = y + dh     base_angle = angle * Math::PI / 180.0     pts = []     POINT_NUM.times { |i|       ang = base_angle + PI_4 * i / POINT_NUM       pts << [dx + (Math.sin(ang) * dw).to_i,         dy - (Math.cos(ang) * dh).to_i]     }     return pts   end   #--------------------------------------------------------------------------   # Parametr x   #--------------------------------------------------------------------------   def x=(value)     @x = value     @points = create_star_points   end   #--------------------------------------------------------------------------   # Parametr y   #--------------------------------------------------------------------------   def y=(value)     @y = value     @points = create_star_points   end   #--------------------------------------------------------------------------   # Szerokość   #--------------------------------------------------------------------------   def width=(value)     @width = value     @points = create_star_points   end   #--------------------------------------------------------------------------   # Wysokość   #--------------------------------------------------------------------------   def height=(value)     @height = value     @points = create_star_points   end   #--------------------------------------------------------------------------   # Kąt   #--------------------------------------------------------------------------   def angle=(value)     @angle = value % 360     @points = create_star_points   end end #============================================================================== # PieRegion #============================================================================== class PieRegion < Region   #--------------------------------------------------------------------------   # Stałe   #--------------------------------------------------------------------------   HALF_PI = Math::PI / 2.0  # PI / 2   #--------------------------------------------------------------------------   # Zmienne   #--------------------------------------------------------------------------   attr_reader   :begin_angle     # [stopnie]   attr_reader   :sweep_angle     # (0 &#65374; 359)   #--------------------------------------------------------------------------   # Rozpoczęcie   #--------------------------------------------------------------------------   def initialize(*args)     super()     shape = args[0]     ang1, ang2 = args[1..2]     case shape     when CircularRegion       @cx = shape.x       @cy = shape.y       self.radius = shape.radius     else       @cx = @cy = @x = @y = @radius = 0     end     self.start_angle = (ang1 == nil ? 0 : ang1)     self.sweep_angle = (ang2 == nil ? 0 : ang2)     @__init = true     create_pie_region   end   #--------------------------------------------------------------------------   # Tworzenie kształtu   #--------------------------------------------------------------------------   def create_pie_region     return unless @__init     st_deg = @start_angle += (@sweep_angle < 0 ? @sweep_angle : 0)     st_deg %= 360     ed_deg = st_deg + @sweep_angle.abs     diff = st_deg % 90     r = @radius * 3 / 2     s = st_deg / 90     e = ed_deg / 90     @region = nil     (s..e).each { |i|       break if i * 90 >= ed_deg       if diff > 0         st_rad = (i * 90 + diff) * Math::PI / 180.0         diff = 0       else         st_rad = i * HALF_PI       end       if (i + 1) * 90 > ed_deg         ed_rad = ed_deg * Math::PI / 180.0       else         ed_rad = (i + 1) * HALF_PI       end       pt1 = [@cx, @cy]       pt2 = [         @cx + Integer(Math.cos(st_rad) * r),         @cy + Integer(Math.sin(st_rad) * r)       ]       pt3 = [         @cx + Integer(Math.cos(ed_rad) * r),         @cy + Integer(Math.sin(ed_rad) * r)       ]       rgn = PolygonRegion.new(pt1, pt2, pt3)       if @region == nil         @region = rgn       else         @region |= rgn       end     }     @region &= CircularRegion.new(@cx, @cy, @radius)     return @region   end   #--------------------------------------------------------------------------   # Parametr x   #--------------------------------------------------------------------------   def x     return @cx   end   #--------------------------------------------------------------------------   # Parametr y   #--------------------------------------------------------------------------   def y     return @cy   end   #--------------------------------------------------------------------------   # Zmiana parametru x   #--------------------------------------------------------------------------   def x=(value)     @cx = value     @x = @cx - @radius     create_pie_region   end   #--------------------------------------------------------------------------   # Zmiana parametru y   #--------------------------------------------------------------------------   def y=(value)     @cy = value     @y = @cy - @radius     create_pie_region   end   #--------------------------------------------------------------------------   # Radiany   #--------------------------------------------------------------------------   def radius=(value)     @radius = value     @x = @cx - @radius     @y = @cy - @radius     create_pie_region   end   #--------------------------------------------------------------------------   # Kąty   #--------------------------------------------------------------------------   def start_angle=(value)     @start_angle = value     create_pie_region   end   #--------------------------------------------------------------------------   # Zmiana kąta   #--------------------------------------------------------------------------   def sweep_angle=(value)     @sweep_angle = [[value, -360].max, 360].min     create_pie_region   end   #--------------------------------------------------------------------------   # Tworzenie kształtu   #--------------------------------------------------------------------------   def create_region_handle     return @region.create_region_handle   end end #============================================================================== # CombinedRegion #============================================================================== class CombinedRegion < Region   #--------------------------------------------------------------------------   # Stałe   #--------------------------------------------------------------------------   # Tryb syntezy   RGN_AND  = 1   RGN_OR   = 2   RGN_XOR  = 3   RGN_DIFF = 4   RGN_COPY = 5   #--------------------------------------------------------------------------   # Win32API   #--------------------------------------------------------------------------   @@_api_combine_rgn = Win32API.new('gdi32', 'CombineRgn', 'llll', 'l')   #--------------------------------------------------------------------------   # Rozpoczęcie   #--------------------------------------------------------------------------   def initialize(mode, region1, region2)     @exp = CombinedRegionExp.new(mode, region1.clone, region2.clone)   end   #--------------------------------------------------------------------------   # Tworzenie kształtu   #--------------------------------------------------------------------------   def create_region_handle     return combine_region(@exp.region1, @exp.region2, @exp.mode)   end   #--------------------------------------------------------------------------   # Region syntezy   #--------------------------------------------------------------------------   def combine_region(dest, src, mode)     hdest = dest.create_region_handle     hsrc  = src.create_region_handle     @@_api_combine_rgn.call(hdest, hdest, hsrc, mode)     return hdest   end   protected :combine_region end #============================================================================== # Struct #============================================================================== # CombinedRegionExp CombinedRegionExp = Struct.new("CombinedRegionExp", :mode, :region1, :region2) class Bitmap   unless method_defined?(:_draw_text)     alias _draw_text draw_text     alias _text_size text_size     case KGC::BitmapExtension::DEFAULT_MODE     when 1  # na       alias draw_text draw_text_na       alias text_size text_size_na     when 2  # fast       alias draw_text draw_text_fast       alias text_size text_size_fast     end   end end Font.default_name = KGC::BitmapExtension::DEFAULT_FONT_NAME[   KGC::BitmapExtension::DEFAULT_MODE]

Demo
brak

Screenshot
brak

Instrukcja
1. Wklej skrypt nad "Main" w Edytorze Skryptu.
2. Dalsza konfiguracja wyjaśniona w skrypcie.

---

bitmap.txt

Pobierz Plik ściągnięto 967 raz(y) 48,13 KB

TRGSSX.dll Umieść bibliotekę w folderze z grą.

Pobierz Plik ściągnięto 1198 raz(y) 155 KB

[Greed]

Mam pewien problem. Ściągnąłem ów bibliotekę i wkleiłem skrypt. Gdy chciałem odpalić grę zawiesił mi się komputer. Po zresetowaniu gdy próbuję wejść w moją grę, pokazuje mi się tekst:"Niespodziewany format pliku" i wychodzi mi z gry. Nie wiem w czym problem, jeśli komuś przytrafiło się coś podobnego i wie jak mi pomóc będę naprawdę wdzięczny.

[Ayene]

Dziwne... u mnie wszystko poprawnie wyświetla... Zacznijmy od kilku pytań
1. Z jakiego systemu operacyjnego korzystasz?
2. Czy na pewno poprawnie skopiowałeś skrypt?
3. Czy umieściłeś w folderze z grą bibliotekę?

Przetłumaczyłam jednak skrypt na polski (najważniejsze linijki), może teraz nie będzie problemów. Podmień te pliki łącznie ze skryptem rozszerzającym okno statusu i ściągnij jeszcze raz bibliotekę (może nie ściągnęła się do końca).

[Greed]

1 Co do systemu jest to zmodyfikowany xp, mianowicie windows mx rgb.
2 Co do skryptu skopiowałem tylko ten który był w dodatku (i myślę że to może być problem)
3 Bibliotekę umieściłem

Nie mogę wejść wogólę w moją grę, więc podmiana skryptu odpada.
Może to być kwestia systemu, może miałem po prostu pecha i zawiesił mi się komp w złym momencie. Jeśli coś uda ci się wymyślić to pisz, jeśli nie to trudno, będę miał okazję zrobić nowy projekt. I tak dziękuję za zajęcie się tym problemem

[Ayene]

Możemy zrobić tak... Załóż nowy projekt i ze swojego starego zgraj wszystkie pliki z folderu Data (te z rozszerzeniem rxdata) - nadpisz je w nowym projekcie - oprócz pliku 'Scripts.rxdata', który jest Twoim edytorem skryptów. Może uda Ci się uratować mapy i bazę danych, a skrypty sobie uzupełnisz Oczywiście jak masz jakieś dodatki do grafiki i muzykę to też ją skopiuj.

A to że skopiowałeś tylko ten skrypt z dodatku nie powinno psuć gry Jest on przecież samodzielny i ogólnie poprawia grafikę.

[megamanmaker]

Siemka!!
Mam pytanko ten skrypt popsuł mi czcionkę którą ustawiłem przez prosty skrypt z youtuba:

Font.default_name = ["Calibri"]
Font.default_bold = false

Czy można temu zaradzić??

[Ayene]

Wystarczy, że - w skrypcie z pierwszego posta - zamiast czcionki Comic Sans MS wpiszesz Calibri (pod warunkiem, że nie zmieniłeś trybu wydajności z DEFAULT_MODE = 2 na inny). Pamiętaj jednak o tym, że w przypadku, gdy wydasz grę, a potencjalny gracz nie będzie miał czcionki Calibri na swoim komputerze - nie będzie mu wyświetlało tekstu.

[megamanmaker]

Wielkie dzięki za pomoc lecz już dawno uporałem się z tym przez inny skrypt lecz muszę powiedzieć że na tej stronce są zej................ skrypty bestiariusza szukałem z 2 miechy i tu nagle na polskiej stronce
lecz niektóre skrypty musiałem edytować żeby napisy były eng

[dawidos989]

można to szczegółowiej lub sarinami lub filmikiem dało by sie zrobić pokazać jak to zrobić?

[ Dodano: Pią 06 Lis, 2009 17:33 ]
prosze zrubće to w skrinach lub w filmie bo mi sie to podoba ale niewiem jak zrobić

[Ayene]

dawidos989, wystarczyło poszukać na forum. Jest przecież tutorial - Dodawnie nowych skryptów

[KillYou]

Gdzie wsadzić tą Bibliotekę TRGSSX?

[Ayene]

W folderze z grą. Nie w podfolderach (Data itd.) tylko obok pliku .exe.

[Asantos]

a takie pytanko co DOKŁADNIE robi ten skrypcik? :)

[Ayene]

Cytat:

Skrypt powiększa możliwości graficzne RPG Maker'a VX.

To co jest najistotniejsze - można w nim zmienić czcionkę i jej wygląd.

[Asantos]

Ayene, ten skrypt ucina mi ogonki "y,g,j" itp. Mam go jakoś przerobić?