O TEMA DO FÓRUM ESTÁ EM MANUTENÇÃO. FEEDBACKS AQUI: ACESSAR

Tips and Tricks - Chuva Realista

Iniciado por Ven, 05/02/2016 às 14:35

Só do evento e da sua lista de scripts. Mas não precisa por em anexo, usa o BBCode da imagem.

Se não souber como faz confere aqui.

Pra mim ficou muito diferente da print. Pode me dizer o que eu talvez tenha feito errado?

[Anexo excluído pelo administrador]

27/07/2016 às 17:24 #17 Última edição: 27/07/2016 às 18:18 por SevenM
 Não se pode usar a mesma configuração para qualquer cena. Você precisa levar em consideração fatores como a coloração natural do tileset, se haverá ou não iluminação(seja de script ou feita manualmente). No final das contas você passará bastante tempo testando e re-testando a cena até que ache a combinação de valores ideais.

E claro, a imagem usada para criar a 'chuva' faz toda diferença também contudo não se limite apenas a uma... Enfim, ao menos foi o que fiz no meu projeto e deu certo.

Jogo em desenvolvimento. Se interessou? Clique na imagem para mais informações!

A assim, malz ai pelas screenshosts era porque eu estou usando o forum mobile, e não sei adicionar fotos pelos outros sites, vi o seu post porem nao ajudou muito na versao mobile, mas posso enviar pelo face, caso queira me adicionar :Pedro caio ~> ai é só proucurar um lindão numa pose super sexy com uma flor

agora, meu outro problema é: como que eu tiro aquela screenshot que eu mandei acima?

Ótimo tutorial meu querido Ven, muito bem explicado e o tópico muito bem organizado, eu já utilizo esse efeito em alguns mapas meus já faz um tempo, porém faço de uma forma um pouco diferente, mas tenho certeza que esse tutorial vai ajudar o pessoal a incrementar os mapas, parabéns pela iniciativa cara!

Abraços do Lyca!  :ok:
Fazer mapas é uma arte, faça como se fosse o seu último.




Eiii,  tenho um grande problema, uso parallax mapping e  a chuva fica em cima da imagem, ou seja em cima das árvores e coisas acima do personagens.

Vou explicar melhor: os objetos ficam abaixo do jogador: 1 camada, o jogador: 2 camada, a chuva(fog): 3 camada, as imagens que eu uso no parallax mapping: 4 camada

Ou seja, a chuva fica como 3 camada, e não a última em cima de tudo(4 camada)

Foi malz ae, expliquei o mais detalhadamente por que eu estou no celular e não posso tirar uma print agora(e nem tão cedo).
Veja meu projeto em andamento (24/7/2016):


Apoio:

Citação de: Neko Tenshi online 27/07/2016 às 19:18
Eiii,  tenho um grande problema, uso parallax mapping e  a chuva fica em cima da imagem, ou seja em cima das árvores e coisas acima do personagens.

Vou explicar melhor: os objetos ficam abaixo do jogador: 1 camada, o jogador: 2 camada, a chuva(fog): 3 camada, as imagens que eu uso no parallax mapping: 4 camada

Ou seja, a chuva fica como 3 camada, e não a última em cima de tudo(4 camada)

Foi malz ae, expliquei o mais detalhadamente por que eu estou no celular e não posso tirar uma print agora(e nem tão cedo).

Dependendo do maker que você usar existe um script que permite que você altere qual a camada que a FOG será apresentada. Eu tive esse problema quando utilizei o sistema pela primeira vez e este acabou ficando pior quando juntado com scripts de iluminação e semelhantes. Posso estar falando besteiras até pelo tempo que não lido com scripts mas ao que me lembre o maker trata as imagens que serão apresentadas por camadas que vão de um valor até outro.(Ex. Panoramas seriam mostrados na camada 0, tilesets entre as camadas 1 e 5, etc etc...) então eu tive de alterar a camada que as FOGs eram apresentadas de forma que ficassem abaixo das pictures porem acima de qualquer scripts de iluminação/overlay. Parece complicado mas não é. No VX Ace inclusive tem um script que permite que você diga em qual camada quer que a FOG seja apresentada, o que torna as coisas muito mais rápidas já que você só precisaria pesquisar qual camada exatamente as pictures ou qualquer overlay que você estiver usando estariam sendo usados.

Jogo em desenvolvimento. Se interessou? Clique na imagem para mais informações!

27/07/2016 às 20:09 #23 Última edição: 27/07/2016 às 20:11 por Neko Tenshi
Bem o problema é que para fazer essa chuva ae, eu preciso desse script, e ele não da a opção de camadas, se eu usasse outro script esse feito realista funcionária?
Veja meu projeto em andamento (24/7/2016):


Apoio:

 É possível chegar nesse efeito usando qualquer script de FOG. Cristo, até com pictures daria se fosse possível fazer a picture em si não ter fim(loop em todas a direções)

Jogo em desenvolvimento. Se interessou? Clique na imagem para mais informações!

27/07/2016 às 21:58 #25 Última edição: 27/07/2016 às 22:00 por Neko Tenshi
Resolvido então, usarei esse efeito com outro script. Isso resolve o problema do posicionamento das camadas de imagem.

Desculpe, sou leigo quando o assunto e fog, vlw pela ajuda [user]SevenM[/user].
Veja meu projeto em andamento (24/7/2016):


Apoio:

 Sem problemas! Eu vi pelo seu perfil que você usa o RPG Maker VX/Ace, certo? Então, vou te passar três scripts essenciais que eu usava no Crimson Tale:(O de FOG incluso)

in-game tone changer:
Spoiler
=begin
		Modificateur de teinte inGame ! 
		------------------------------------------------------
		Par Grim (http://blog.gri.im)
		Funkywork - Biloucorp

		Un tout grand merci à Zeus81 pour sa précieuse aide (sur les arguments
		et pour le 'v' :P)

		Idée originale de Siegfried, merci à lui ! 

		Merci à Magicalichigo et Nuki pour leur aide aussi :)

		Concept
		------------------------------------------------------
		Je suis un grand utilisateur des tons d'écran sous RM, 
		le problème c'est que l'on est jamais satisfait du premier coup
		donc il faut recompiler le projet plusieurs fois...
		Avec ce script, vous avez, en mode test (donc uniquement lancé
		depuis l'éditeur) une fenêtre de test des teintes en temps réel.
		La touche pour appeller/masquer la fenêtre est F3 par défaut,
		Vous pouvez la changer via le module Tint_Config, il suffit 
		de modifier la constante KEY.

		J'espère que ce script sera utile ! 

=end
#==============================================================================
# ** Tint_Config
#------------------------------------------------------------------------------
#  Configuration du script
#==============================================================================

module Tint_Config
	#--------------------------------------------------------------------------
	# * Liste des touches
	#--------------------------------------------------------------------------
	F1	= 0x70
	F2	= 0x71
	F3	= 0x72
	F4	= 0x73
	F5	= 0x74
	F6	= 0x75
	F7	= 0x76
	F8	= 0x77
	F9	= 0x78
	F10	= 0x79
	F11	= 0x7A
	F12	= 0x7B
	#--------------------------------------------------------------------------
	# * Touche d'activation du menu de teinte
	#--------------------------------------------------------------------------
	KEY = F3
end

#==============================================================================
# ** Module d'interaction Utilisateur
#------------------------------------------------------------------------------
#  Ensemble des outils de saisie utilisateur
#==============================================================================

module GUI
	#--------------------------------------------------------------------------
	# * Librairies
	#--------------------------------------------------------------------------
	FindWindowA = Win32API.new('user32', 'FindWindowA', 'pp', 'l')
	GetPrivateProfileStringA = Win32API.new('kernel32', 'GetPrivateProfileStringA', 'pppplp', 'l')
	GetWindowRect = Win32API.new('user32','GetWindowRect','lp','i')
	ScreenToClient = Win32API.new('user32', 'ScreenToClient', 'lp', 'i')
	GetAsyncKeyState = Win32API.new('user32', 'GetAsyncKeyState', 'i', 'i')
	GetKeyState = Win32API.new('user32', 'GetKeyState', 'i', 'i')
	CreateWindowEx = Win32API.new("user32","CreateWindowEx",'lpplllllllll','l')
	ShowWindow = Win32API.new('user32','ShowWindow','ll','l')
	DestroyWindow = Win32API.new('user32','DestroyWindow','p','l')
	MoveWindow = Win32API.new('user32','MoveWindow','liiiil','l')
	SendMessage = Win32API.new('user32','SendMessage','llll','l') 
	SetWindowText = Win32API.new('user32','SetWindowText','pp','i')
	#--------------------------------------------------------------------------
	# * Styles
	#--------------------------------------------------------------------------
	WS_BORDER = 0x00800000
	WS_POPUP = 0x80000000
	WS_VISIBLE = 0x10000000
	WS_SYSMENU = 0x00080000
	WS_CLIPSIBLINGS = 0x04000000
	WS_CAPTION = 0x00C00000
	WS_TILED = 0x00000000
	WS_DLGFRAME = 0x00400000
	WS_CHILD = 0x40000000
	WS_EX_WINDOW_EDGE = 0x00000100
	WS_EX_APPWINDOW = 0x00040000
	WS_EX_TOOLWINDOW = 0x00000080
	TBS_AUTOTICKS = 1
	TBS_ENABLESELRANGE = 32
	TBS_NOTIFY  = 0x0001
	TBM_SETRANGE = 1030
	TBM_SETPOS = 1029
	TBM_GETPOS = 1024
	TBM_GETMAX = 1031
	TRACKBAR_CLASS = "msctls_trackbar32"

	#--------------------------------------------------------------------------
	# * Singleton
	#--------------------------------------------------------------------------
	class << self
		#--------------------------------------------------------------------------
		# * Retourne la fenêtre RGSS
		#--------------------------------------------------------------------------
		def handle
			name = [].pack("x256")
			GetPrivateProfileStringA.call('Game', 'Title', '', name, 255, ".\\Game.ini")
			name.delete!("\x00")
			FindWindowA.call('RGSS Player', name)
		end
		#--------------------------------------------------------------------------
		# * Retourne le RECT de la fenêtre sur l'écran
		#--------------------------------------------------------------------------
		def window_rect
			buffer = [0,0,0,0].pack('l4')
			GetWindowRect.call(handle, buffer)
			return Rect.new(*buffer.unpack('l4'))
		end
	end

	#==============================================================================
	# ** Window_Track
	#------------------------------------------------------------------------------
	#  Fenêtre qui contiendra les sliders
	#==============================================================================

	class Window_Track
		#--------------------------------------------------------------------------
		# * Variable de classe
		#--------------------------------------------------------------------------
		@@HWND = GUI.handle
		#--------------------------------------------------------------------------
		# * variables d'instances
		#--------------------------------------------------------------------------
		attr_reader :visibility
		#--------------------------------------------------------------------------
		# * Constructeur
		#--------------------------------------------------------------------------
		def initialize(r=0,v=0,b=0,g=-255)
			@visibility = false
			name = "Modification de la teinte"
			@w, @h = 280, 200
			@x, @y = GUI.window_rect.x-@w-16, GUI.window_rect.y
			ex_style = WS_EX_WINDOW_EDGE|WS_EX_APPWINDOW|WS_EX_TOOLWINDOW
			dw_style = WS_POPUP|WS_DLGFRAME|WS_TILED|WS_CAPTION
			args = [ex_style, "static", name, dw_style, @x,@y,@w,@h, @@HWND, 0,0,0]
			@window = CreateWindowEx.call(*args)
			args2 = [0, "static", "[R: #{r}] [V: #{v}] [B: #{b}] [G: #{g}]", WS_CHILD|WS_VISIBLE,10,150,260,40, @window, 0,0,0]
			@red = UI_Slider.new("red", 10, 32, @window, r)
			@green = UI_Slider.new("green", 10, 64, @window, v)
			@blue = UI_Slider.new("blue", 10, 96, @window, b)
			@gray = UI_Slider.new("gray", 10, 128, @window, g)
			@text = CreateWindowEx.call(*args2)
		end
		#--------------------------------------------------------------------------
		# * Get value
		#--------------------------------------------------------------------------
		def get_value(sym)
			return @red.get_value if sym == :red || sym == :r
			return @green.get_value if sym == :green || sym == :g
			return @blue.get_value if sym == :blue || sym == :b
			return @gray.get_value
		end
		#--------------------------------------------------------------------------
		# * Delete
		#--------------------------------------------------------------------------
		def delete
			DestroyWindow.call(@window)
		end
		#--------------------------------------------------------------------------
		# * Display textbox
		#--------------------------------------------------------------------------
		def set_visibility(value, r=0, v=0, b=0, g=-255)
			@visibility = !!value
			flag = (value) ? 1 : 0
			@red.set_value r
			@green.set_value v
			@blue.set_value b
			@gray.set_value g
			ShowWindow.call(@window, flag)
			set_text r, v, b, g
		end
		#--------------------------------------------------------------------------
		# * set text
		#--------------------------------------------------------------------------
		def set_text(r, v, b, g)
			SetWindowText.call(@text, "[R: #{r}] [V: #{v}] [B: #{b}] [G: #{g}]")
		end
	end

	#==============================================================================
	# ** UI_Slider
	#------------------------------------------------------------------------------
	#  Décris un slider
	#==============================================================================

	class UI_Slider
		#--------------------------------------------------------------------------
		# * Constructeur
		#--------------------------------------------------------------------------
		def initialize(name, x, y, hwnd, value)
			@hwnd = hwnd
			dw_style = WS_CHILD|WS_VISIBLE|TBS_NOTIFY
			args = [0, TRACKBAR_CLASS, name, dw_style, x, y, 255, 32, @hwnd, 0,0,0]
			@track = CreateWindowEx.call(*args)
			SendMessage.call(@track, TBM_SETRANGE, 1, [-255, 255].pack('SS').unpack('L')[0])
			SendMessage.call(@track, TBM_SETPOS, 1, value)
		end
		#--------------------------------------------------------------------------
		# * Get Value
		#--------------------------------------------------------------------------
		def get_value
			return SendMessage.call(@track, TBM_GETPOS, 0, 0)
		end
		#--------------------------------------------------------------------------
		# * Set Value
		#--------------------------------------------------------------------------
		def set_value(val)
			return SendMessage.call(@track, TBM_SETPOS, 1, val)
		end
	end
end

#==============================================================================
# ** Module Input
#------------------------------------------------------------------------------
#  Ajout de la gestion de la Palette
#==============================================================================

module Input
	#--------------------------------------------------------------------------
	# * variables de classe
	#--------------------------------------------------------------------------
	@@window_Track = GUI::Window_Track.new
	#--------------------------------------------------------------------------
	# * Singleton
	#--------------------------------------------------------------------------
	class << self
		#--------------------------------------------------------------------------
		# * Alias
		#--------------------------------------------------------------------------
		alias tint_update update
		#--------------------------------------------------------------------------
		# * Input update
		#--------------------------------------------------------------------------
		def update
			tint_update
			rmvxace = $game_map.respond_to?(:screen)
			flag =(rmvxace && defined?(SceneManager)) ? SceneManager.scene : $scene
			if ($TEST||$DEBUG) && flag.is_a?(Scene_Map)
				if rmvxace
					screen = $game_map.screen
					key_press = lambda do |key|
						GUI::GetAsyncKeyState.call(key)&0x01 == 1
					end
				else
					screen = $game_screen
					key_press = lambda do |key|
						!GUI::GetKeyState.call(key).between?(0, 1)
					end
				end
				t = screen.tone
				if key_press.call(Tint_Config::KEY)
					@@window_Track.set_visibility(!@@window_Track.visibility, t.red, t.green, t.blue, t.gray)
					sleep(0.2) unless rmvxace
				end
				r, v, b, g = @@window_Track.get_value(:r), @@window_Track.get_value(:g),@@window_Track.get_value(:b), @@window_Track.get_value(:gr)
				r_check = t.red != r
				g_check = t.green != v
				b_check = t.green != b
				gr_check = t.gray != g
				if (r_check || g_check || b_check || gr_check) && @@window_Track.visibility
					new_tone = Tone.new(r,v,b,g)
					screen.start_tone_change(new_tone, 0)
					@@window_Track.set_text(r,v,b,g)
				end
			end
		end
	end
end
[close]

Multi Layer FOG:
Spoiler
#============================================================================
# Multi Layer Fog
# v1.0 by Shaz
#----------------------------------------------------------------------------
# This script lets you add one or more layers of fog to a map.
# You can add vertical and/or horizontal scrolling to each fog layer.
# You can have fog appear on top of the map or behind the map (above the
# parallax layer).
# You can adjust the fog's opacity and tone over time.
#----------------------------------------------------------------------------
# To Install:
# Copy and paste into a new script slot in Materials.  This script aliases
# existing methods, so can go below all other custom scripts.
#----------------------------------------------------------------------------
# To Use:
# Create a Fogs folder inside your game's Graphics folder, and paste your
# fog png files there.
#
# To add fog to a map, use the following in a Call Script event command:
#    show_fog(number, "filename", hue, opacity, blend_type, zoom, 
#      speed-x, speed-y, z)
# - only number and filename are mandatory
# - fog is added like pictures - the number is simply an id (an array index),
#   and if you don't specify the z value, fog with a higher number/id is drawn
#   over fog with a lower number/id
# - z position defaults to above the player.  If you want to show fog above the 
#   parallax layer but behind the map, use a negative value for z.  The 
#   parallax is drawn at -100
#
# To change fog tone, use the following in a Call Script event command:
#    tint_fog(number, red, green, blue, gray, duration)
#
# To change the fog opacity, use the following in a Call Script event command:
#    fade_fog(number, opacity, duration)
#
# To remove fog, use the following in a Call Script event command:
#    erase_fog(number)
#
# By default fog will be removed when you change maps, and battle screens 
# will have the same fog as the map.  Change the CUSTOMIZATION options below
# if you do not want this.
#----------------------------------------------------------------------------
# Terms:
# Use in free or commercial games
# Credit Shaz
#============================================================================

#============================================================================
# CUSTOMIZATION
#
# Set this to true or false to show (or not show) fog in the battle screen
BATTLE_FOGS = true

# Set this to true or false to clear (or not clear) fogs on transfer to new map
CLEAR_ON_TRANSFER = true

# DO NOT CHANGE ANYTHING BELOW THIS LINE
#============================================================================


module Cache
  #--------------------------------------------------------------------------
  # * Get Fog
  #--------------------------------------------------------------------------
  def self.fog(filename, hue)
    load_bitmap("Graphics/Fogs/", filename, hue)
  end
end

class Game_Screen
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader   :fogs
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  alias shaz_multi_fog_game_screen_initialize initialize
  def initialize
    @fogs = Game_Fogs.new
    shaz_multi_fog_game_screen_initialize
  end
  #--------------------------------------------------------------------------
  # * Clear
  #--------------------------------------------------------------------------
  alias shaz_multi_fog_game_screen_clear clear
  def clear
    shaz_multi_fog_game_screen_clear
    clear_fogs
  end
  #--------------------------------------------------------------------------
  # * Clear Fogs
  #--------------------------------------------------------------------------
  def clear_fogs
    @fogs.each {|fog| fog.erase}
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  alias shaz_multi_fog_game_screen_update update
  def update
    shaz_multi_fog_game_screen_update
    update_fogs
  end
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def update_fogs
    @fogs.each {|fog| fog.update}
  end
end
  
class Game_Fog
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader   :number
  attr_reader   :name
  attr_reader   :hue
  attr_reader   :opacity
  attr_reader   :blend_type
  attr_reader   :zoom
  attr_reader   :sx
  attr_reader   :sy
  attr_reader   :ox
  attr_reader   :oy
  attr_reader   :tone
  attr_reader   :z
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(number)
    @number = number
    init_basic
    init_movement
    init_tone
    init_opacity
  end
  #--------------------------------------------------------------------------
  # * Initialize Basic Variable
  #--------------------------------------------------------------------------
  def init_basic
    @name = ""
    @hue = 90
    @blend_type = 0
    @zoom = 200
    @sx = @sy = 0
  end
  #--------------------------------------------------------------------------
  # * Initialize Movement Variable
  #--------------------------------------------------------------------------
  def init_movement
    @ox = @oy = 0
  end
  #--------------------------------------------------------------------------
  # * Initialize Tone
  #--------------------------------------------------------------------------
  def init_tone
    @tone = Tone.new
    @tone_target = Tone.new
    @tone_duration = 0
  end
  #--------------------------------------------------------------------------
  # * Initialize Opacity
  #--------------------------------------------------------------------------
  def init_opacity
    @opacity = 64.0
    @opacity_target = 64.0
    @opacity_duration = 0
  end
  #--------------------------------------------------------------------------
  # * Show Fog
  #--------------------------------------------------------------------------
  def show(name, hue, opacity, blend_type, zoom, sx, sy, z)
    @name = name
    @hue = hue
    @opacity = opacity
    @blend_type = blend_type
    @zoom = zoom
    @sx = @sx2 = sx
    @sy = @sy2 = sy
    @z = z.nil? ? 300 + @number : z
    init_movement
  end
  #--------------------------------------------------------------------------
  # * Start Changing Tone
  #--------------------------------------------------------------------------
  def start_tone_change(tone, duration)
    @tone_target = tone.clone
    @tone_duration = duration
    @tone = @tone_target.clone if @tone_duration == 0
  end
  #--------------------------------------------------------------------------
  # * Start Opacity Change
  #--------------------------------------------------------------------------
  def start_opacity_change(opacity, duration)
    @opacity_target = opacity * 1.0
    @opacity_duration = duration
    @opacity = @opacity_target if @opacity_duration == 0
  end
  #--------------------------------------------------------------------------
  # * Erase Fog
  #--------------------------------------------------------------------------
  def erase
    @name = ""
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    update_move
    update_tone_change
    update_opacity_change
  end
  #--------------------------------------------------------------------------
  # * Update Fog Move
  #--------------------------------------------------------------------------
  def update_move
    @sx2 -= @sx / 8.0
    @sy2 -= @sy / 8.0
    
    @ox = $game_map.display_x * 32 + @sx2
    @oy = $game_map.display_y * 32 + @sy2
    return
  end
  #--------------------------------------------------------------------------
  # * Update Fog Tone Change
  #--------------------------------------------------------------------------
  def update_tone_change
    return if @tone_duration == 0
    d = @tone_duration
    target = @tone_target
    @tone.red = (@tone.red * (d - 1) + target.red) / d
    @tone.green = (@tone.green * (d - 1) + target.green) / d
    @tone.blue = (@tone.blue * (d - 1) + target.blue) / d
    @tone.gray = (@tone.gray * (d - 1) + target.gray) / d
    @tone_duration -= 1
  end
  #--------------------------------------------------------------------------
  # * Update Fog Opacity Change
  #--------------------------------------------------------------------------
  def update_opacity_change
    return if @opacity_duration == 0
    d = @opacity_duration
    @opacity = (@opacity * (d - 1) + @opacity_target) / d
    @opacity_duration -= 1
  end
end

class Game_Fogs
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    @data = []
  end
  #--------------------------------------------------------------------------
  # * Get Picture
  #--------------------------------------------------------------------------
  def [](number)
    @data[number] ||= Game_Fog.new(number)
  end
  #--------------------------------------------------------------------------
  # * Iterator
  #--------------------------------------------------------------------------
  def each
    @data.compact.each {|fog| yield fog } if block_given?
  end
end

if CLEAR_ON_TRANSFER
  class Game_Player < Game_Character
    #--------------------------------------------------------------------------
    # * Execute Player Transfer
    #--------------------------------------------------------------------------
    alias shaz_multi_fog_game_player_perform_transfer perform_transfer
    def perform_transfer
      if transfer? && @new_map_id != $game_map.map_id
        $game_map.screen.fogs.each { |fog| fog.erase }
      end
      shaz_multi_fog_game_player_perform_transfer
    end
  end
end

class Game_Interpreter
  #--------------------------------------------------------------------------
  # * Show Fog
  #--------------------------------------------------------------------------
  def show_fog(number, name, hue = 90, opacity = 64.0, blend_type = 0, zoom = 200, 
    sx = 0, sy = 0, z = nil)
    screen.fogs[number].show(name, hue, opacity, blend_type, zoom, sx, sy, z)
  end
  #--------------------------------------------------------------------------
  # * Tint Fog
  #--------------------------------------------------------------------------
  def tint_fog(number, red, green, blue, gray, duration)
    screen.fogs[number].start_tone_change(Tone.new(red, green, blue, gray),
      duration)
  end
  #--------------------------------------------------------------------------
  # * Change Fog Opacity
  #--------------------------------------------------------------------------
  def fade_fog(number, opacity, duration)
    screen.fogs[number].start_opacity_change(opacity, duration)
  end
  #--------------------------------------------------------------------------
  # * Erase Fog
  #--------------------------------------------------------------------------
  def erase_fog(number)
    screen.fogs[number].erase
  end
end

class Plane_Fog < Plane
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(viewport, fog)
    super(viewport)
    @fog = fog
    self.z = @fog.z
    self.zoom_x = @fog.zoom / 100
    self.zoom_y = @fog.zoom / 100
    self.blend_type = @fog.blend_type
    update
  end
  #--------------------------------------------------------------------------
  # * Free
  #--------------------------------------------------------------------------
  def dispose
    bitmap.dispose if bitmap
    super
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    update_bitmap
    update_move
    update_tone
    update_opacity
  end
  #--------------------------------------------------------------------------
  # * Update Bitmap
  #--------------------------------------------------------------------------
  def update_bitmap
    if @fog.name.empty?
      self.bitmap = nil
    else
      self.bitmap = Cache.fog(@fog.name, @fog.hue)
    end
  end
  #--------------------------------------------------------------------------
  # * Update Move
  #--------------------------------------------------------------------------
  def update_move
    self.ox = @fog.ox
    self.oy = @fog.oy
  end
  #--------------------------------------------------------------------------
  # * Update Tone
  #--------------------------------------------------------------------------
  def update_tone
    self.tone = @fog.tone
  end
  #--------------------------------------------------------------------------
  # * Update Opacity
  #--------------------------------------------------------------------------
  def update_opacity
    self.opacity = @fog.opacity
  end
end  

class Spriteset_Map
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  alias shaz_multi_fog_spriteset_map_initialize initialize
  def initialize
    shaz_multi_fog_spriteset_map_initialize
    create_fogs
    update
  end
  #--------------------------------------------------------------------------
  # * Create Fog Plane
  #--------------------------------------------------------------------------
  def create_fogs
    @fog_planes = []
  end
  #--------------------------------------------------------------------------
  # * Free
  #--------------------------------------------------------------------------
  alias shaz_multi_fog_spriteset_map_dispose dispose
  def dispose
    dispose_fogs
    shaz_multi_fog_spriteset_map_dispose
  end
  #--------------------------------------------------------------------------
  # * Free Fog Plane
  #--------------------------------------------------------------------------
  def dispose_fogs
    @fog_planes.compact.each {|fog| fog.dispose }
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  alias shaz_multi_fog_spriteset_map_update update
  def update
    update_fogs
    shaz_multi_fog_spriteset_map_update
  end
  #--------------------------------------------------------------------------
  # * Update Fogs
  #--------------------------------------------------------------------------
  def update_fogs
    return if !@fog_planes
    $game_map.screen.fogs.each do |fog|
      @fog_planes[fog.number] ||= Plane_Fog.new(@viewport1, fog)
      @fog_planes[fog.number].update
    end
  end
end

if BATTLE_FOGS
  class Spriteset_Battle
    #--------------------------------------------------------------------------
    # * Object Initialization
    #--------------------------------------------------------------------------
    alias shaz_multi_fog_spriteset_battle_initialize initialize
    def initialize
      shaz_multi_fog_spriteset_battle_initialize
      create_fogs
      update
    end
    #--------------------------------------------------------------------------
    # * Create Fog Plane
    #--------------------------------------------------------------------------
    def create_fogs
      @fog_planes = []
    end
    #--------------------------------------------------------------------------
    # * Free
    #--------------------------------------------------------------------------
    alias shaz_multi_fog_spriteset_map_dispose dispose
    def dispose
      dispose_fogs
      shaz_multi_fog_spriteset_map_dispose
    end
    #--------------------------------------------------------------------------
    # * Free Fog Plane
    #--------------------------------------------------------------------------
    def dispose_fogs
      @fog_planes.compact.each {|fog| fog.dispose }
    end
    #--------------------------------------------------------------------------
    # * Frame Update
    #--------------------------------------------------------------------------
    alias shaz_multi_fog_spriteset_map_update update
    def update
      update_fogs
      shaz_multi_fog_spriteset_map_update
    end
    #--------------------------------------------------------------------------
    # * Update Fogs
    #--------------------------------------------------------------------------
    def update_fogs
      return if !@fog_planes
      $game_map.screen.update_fogs
      $game_map.screen.fogs.each do |fog|
        @fog_planes[fog.number] ||= Plane_Fog.new(@viewport1, fog)
        @fog_planes[fog.number].update
      end
    end
  end
end # BATTLE_FOGS
[close]

KGC BitmapExtension:
Spoiler
[code]#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
#_/    ◆ KGC_BitmapExtension ◆ XP/VX/VXA ◆
#_/    ◇ Last update : 2009/09/13 ◇
#_/----------------------------------------------------------------------------
#_/  Adding various drawing functions to the Bitmap Class
#_/ You can use this in both XP and VX
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/

#==============================================================================
# ★  Customization BEGIN ★
#==============================================================================

module KGC
module BitmapExtension
  # ◆ Action/movement mode of draw_text
  #   0 : draw_text (default)
  #   1 : draw_text_na
  #   2 : draw_text_fast
  # selecting 1 or 2, draw_text will be set to draw_text_na or draw_text_fast respectively.
  # you can call the original draw_text by _draw_text
  DEFAULT_MODE = 0

  # ◆ Default fonts of each mode
  #   ["Font1", "Font2",...],
  #  Follow the above format to set fonts.
  DEFAULT_FONT_NAME = [
    Font.default_name,  # 0
    Font.default_name,  # 0
    Font.default_name,  # 2
  ]

  # ◆ Hemming using default
  #  Not effective on draw_text
  DEFAULT_FRAME = true

  # ◆ Default gradient colors
  #  Use "nil" if not using gradients
  #  Not effective on draw_text
  DEFAULT_GRAD_COLOR = nil
end
end

#==============================================================================
# ☆ Customization END ☆
#==============================================================================

=begin
━━━━━ Loading Method━━━━━━━━━━━━━━━━━━━━━━━━
──── Class - Bitmap ────────────────────────────
rop_blt(x, y, src_bitmap, src_rect[, rop])
  x, y       : The coordinates X,Y for drawing
  src_bitmap :  The Bitmap that you are to draw
  src_rect   : The transmission scope of src_bitmap
  rop        : Raster Operation Code
               SRCCOPY, SRCPAINT, SRCAND, SRCINVERT, SRCERASE,
               NOTSRCCOPY, NOTSRCERASE
               (default: SRCCOPY)

Uses Raster Operation to draw src_bitmap

--------------------------------------------------------------------------------
blend_blt(x, y, src_bitmap, src_rect[, blend_type])
  x, y       : The coordinates X,Y for drawing
  src_bitmap : The Bitmap that you are to draw
  src_rect   : The transmission scope of src_bitmap
  blend_type : Blending Type
               BLEND_NORMAL, BLEND_ADD, BLEND_SUB, BLEND_MUL, BLEND_HILIGHT
               (Default: BLEND_NORMAL)

Uses special blending types to draw scr_bitmap
--------------------------------------------------------------------------------
clip_blt(x, y, src_bitmap, src_rect, region)
  x, y       : The coordinates X,Y for drawing
  src_bitmap : The Bitmap that you are to draw
  src_rect   : The transmission scope of src_bitmap
  region     :  territory to perform clipping
Using Region to cut out, and to draw src_bitmap
--------------------------------------------------------------------------------
stretch_blt_r(dest_rect, src_bitmap, src_rect[, opacity])
  dest_rect  : rectangle area of the drawing area
  src_bitmap : The Bitmap that you are to draw
  src_rect   : The transmission scope of src_bitmap
  opacity    : Opacity (Default:255)

High resolution scale-up/down block transmission
--------------------------------------------------------------------------------
skew_blt(x, y, src_bitmap, src_rect, slope[, opacity])
  x, y       : The coordinates X,Y for drawing
  src_bitmap : The Bitmap that you are to draw
  src_rect   : The transmission scope of src_bitmap
  slope      : Slope (-90 ~ 90)
  opacity    : Opacity (Default:255)

Makes src_bitmap into a parallelogram
Will not perform interpolation processing.

--------------------------------------------------------------------------------
skew_blt_r(x, y, src_bitmap, src_rect, slope[, opacity])
  x, y       : The coordinates X,Y for drawing
  src_bitmap : The Bitmap that you are to draw
  src_rect   : The transmission scope of src_bitmap
  slope      : Slope (-90 ~ 90)
  opacity    : Opacity (Default:255)

Makes src_bitmap into parallelogram
Same interpolation processing as stretch_blt_r

--------------------------------------------------------------------------------
draw_polygon(points, color[, width])
  points : Coordinate list (each element [x,y])
  color  : Drawing color
  width  : line width (default: 1 )

Draws a shape by connecting each coordinate
--------------------------------------------------------------------------------
fill_polygon(points, start_color, end_color)
  points      : Coordinate list (each element [x,y])
  start_color : Central (main) color
  end_color   : peripheral color

Fills a shape drawn by connecting each coordinate with color
--------------------------------------------------------------------------------
draw_regular_polygon(x, y, r, n, color[, width])
  x, y  : Central coordinate
  r     : radius of the circumscribed circle
  n     : number of vertices/apices 
  color : drawing color
  width : line width (default: 1 )

Draws a shape with n vertices inscribed within a circle with center x,y, radius r
--------------------------------------------------------------------------------
fill_regular_polygon(x, y, r, n, start_color, end_color)
    x, y  : Central coordinate
  r     : radius of the circumscribed circle
  n     : number of vertices/apices 
  start_color : Central color
  end_color   : Peripheral color

Fills a shape with n vertices inscribed within a circle with center x,y, radius r
--------------------------------------------------------------------------------
draw_spoke(x, y, r, n, color[, width])
  x, y  : Central coordinate
  r     : radius of the circumscribed circle
  n     : number of vertices/apices 
  color : drawing color
  width : line width (default: 1 )
Draws spoke for a circle centered at x,y, radius r
--------------------------------------------------------------------------------
draw_text_na(x, y, width, height, text[, align])
draw_text_na(rect, text[, align])
  x, y          : Coordinates for drawing
  width, height : Drawing size
  rect          : rectangle area of drawing
  text          : text
  align         : alignment (Default: 0)

Drawing text without anti-alias
--------------------------------------------------------------------------------
draw_text_fast(x, y, width, height, text[, align])
draw_text_fast(rect, text[, align])
x, y          : Coordinates for drawing
  width, height : Drawing size
  rect          : rectangle area of drawing
  text          : text
  align         : alignment (Default: 0)

Drawing text with anti-alias quickly
--------------------------------------------------------------------------------
text_size_na(text)
  text : target text

Acquires the "Rect" rectangle made during drawing text through draw_text_na
--------------------------------------------------------------------------------
text_size_fast(text)
  text : target text
Acquires the "Rect" rectangle made during drawing text through draw_text_fast


--------------------------------------------------------------------------------
save(filename)
  filename : folder/place where you plan to save the file at

Saves as Bitmap file
Alpha Channel will be discarded.


━━━━━ Loading Class━━━━━━━━━━━━━━━━━━━━━━━━━
Region

Super Class of each region
--------------------------------------------------------------------------------
RectRegion < Region

    -  constructor  -
  (x, y, width, height)
  (rect)

    - public member -
  x, y, width, height : size and position of regtangle

Rectangular Region.
The rectangle that was set will become the drawing region.

--------------------------------------------------------------------------------
RoundRectRegion < RectRegion

    -  constructor-
  (x, y, width, height[, width_ellipse[, height_ellipse]])
    width_ellipse  : width of the roundness of the angle
    height_ellipse : height of the roundness of the angle
  (rect[, width_ellipse[, height_ellipse]])

    - public member -
public member of RectRegion
  width_ellipse, height_ellipse : Roundness of the angle

Round-cornered rectangular region
The rectangle with inputted values with round corners will become the drawing region.

--------------------------------------------------------------------------------
EllipticRegion < RectRegion

    -  constructor-
  (x, y, width, height)
  (rect)
    - public member -
  public member of RectRegion

。Elliptical Region
Draws an ellipse inscribed within the set rectangle

--------------------------------------------------------------------------------
CircularRegion < EllipticRegion

    - Constructor -
  (x, y, radius)
    x, y   : Central coordinates
    radius : radius

    - Public member-
  x, y, radius : center and radius

Circular Region
Drawing area is the circle with the inputted center and radius

--------------------------------------------------------------------------------
PolygonRegion < Region

    - Constructor -
  (point1, point2, ...)
    point : Coordinates in the form [x,y]

    - Public member -
  points    : Coordinate list in the form [x,y]
  fill_mode : Fill mode of polygons
                ALTERNATE : Only the areas between odd and even line segments
                WINDING   : areas between all line segments
              Default is WINDING

Polygonal Region
Creates a polygonal drawing area by connecting the coordinate list.

--------------------------------------------------------------------------------
StarRegion < PolygonRegion

    - Constructor -
  (x, y, width, height[, angle])
  (region[, angle])
    region : Rect, RectRegion, EllipticRegion, CircularRegion (One of these)
    angle  : Starting angle (Default:0)

    - Public member -
  fill_mode           : Same as in  PolygonRegion
  x, y, width, height : Rectangle set as the standard
  angle               : Rotation angle (0~359)

Star Region
a star shaped drawing area inscribed inside an oval inscribed inside the rectangle set as the standard.
Rotation is clockwise

--------------------------------------------------------------------------------
PieRegion < Region

    - Constructor -
  (region, start_angle, sweep_angle)
    region      : Standard CircularRegion
    start_angle : Starting angle
    sweep_angle : Drawing angle (-360 ~ 360)

    - Public Member -
  x, y, radius : Center and Radius
  start_angle  : Starting angle
  sweep_angle  : Drawing angle (-360~360)

Fan-shaped region
Creates a fan-shaped (like a piece of pie) drawing region from the beginning angle in the standard circle to the drawing angle
Starting angle is clockwise originating from 0 in the rightward direction. You can also set negative numbers.

--------------------------------------------------------------------------------
CombinedRegion < Region

Combined Region
Can be created through the following formulae.

  r1 & r2
  r1 * r2
product of r1 and r2(takes common area of r1 and r2)

  r1 | r2
  r1 + r2
sum of r1 and r2 (takes up both r1 and r2)

  r1 ^ r2
Creates a Venn diagram and takes the overlapping area (Only takes the area in either region, not both)

  r1 - r2
difference between r1 and r2 (Deletes area of overlap between r1 and r2 from r1)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
=end

$imported = {} if $imported == nil
$imported["BitmapExtension"] = true

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# □ TRGSSX
#------------------------------------------------------------------------------
#   "TRGSSX.dll" This module handles the functions described above.
#==============================================================================

module TRGSSX
  # 合成タイプ
  BLEND_NORMAL  = 0  # 通常
  BLEND_ADD     = 1  # 加算
  BLEND_SUB     = 2  # 減算
  BLEND_MUL     = 3  # 乗算
  BLEND_HILIGHT = 4  # 覆い焼き

  # ラスタオペレーションコード
  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

  # 補間方法
  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

  # スムージングモード
  SM_INVALID     = -1
  SM_DEFAULT     = 0
  SM_HIGHSPEED   = 1
  SM_HIGHQUALITY = 2
  SM_NONE        = 3
  SM_ANTIALIAS   = 4

  # 塗り潰しモード
  FM_FIT    = 0  # 形状通り
  FM_CIRCLE = 1  # 外接円

  # フォントスタイル
  FS_BOLD      = 0x0001  # ボールド
  FS_ITALIC    = 0x0002  # イタリック
  FS_UNDERLINE = 0x0004  # 下線
  FS_STRIKEOUT = 0x0008  # 取り消し線
  FS_SHADOW    = 0x0010  # 影
  FS_FRAME     = 0x0020  # 縁取り

  DLL_NAME = 'TRGSSX'
  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 "\"#{DLL_NAME}.dll\" が見つからない、" +
      "もしくは古いバージョンを使用しています。"
    exit
  end

  module_function
  #--------------------------------------------------------------------------
  # ○ バージョン取得
  #     (<例> 1.23 → 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,
      f
[close]

Jogo em desenvolvimento. Se interessou? Clique na imagem para mais informações!

aee voltei agora percebi o meu erro, já consertei e agora está perfeito, percebi que no script eu coloquei "rain 1" e na hora de chamar eu coloquei "rain1" bom galera percebi que sim conta um espaço no script.

O link da imagem tá quebrado

Olá!

Gostei muito do tutorial, porém, o arquivo "Sistemas" para baixar do tutorial está fora.

Tem como mandar o link novo?

Obrigadão!