Jump to content
Rpg²S Forum

dark_house

Utenti
  • Posts

    63
  • Joined

  • Last visited

Posts posted by dark_house

  1. nn me ne intendo mai sucsate sempre il disturbo per i topic aperti

    notate questo script, riguarda nell'avere il bestiario per? qualcosa nn va xk? nn so ocme far combaciare il bestiario con l'immagine e ad averla nell'inventario
     

     

     

    # by DaD and RagnarokM
    
    module Enemy_Book_Config
    	DROP_ITEM_NEED_ANALYZE = false
    	EVA_NAME = "Evasion"
    	SHOW_COMPLETE_TYPE = 3
    end
    
    class Game_Temp
    	attr_accessor :enemy_book_data
    	alias temp_enemy_book_data_initialize initialize
    	def initialize
    		temp_enemy_book_data_initialize
    		@enemy_book_data = Data_MonsterBook.new
    	end
    end
    
    class Game_Party
    	attr_accessor :enemy_info
    	#--------------------------------------------------------------------------
    	alias book_info_initialize initialize
    	def initialize
    		book_info_initialize
    		@enemy_info = {}
    	end
    	#--------------------------------------------------------------------------
    	def add_enemy_info(enemy_id, type = 0)
    		case type
    		when 0
    			if @enemy_info[enemy_id] == 2
    				return false
    			end
    			@enemy_info[enemy_id] = 1
    		when 1
    			@enemy_info[enemy_id] = 2
    		when -1
    			@enemy_info[enemy_id] = 0
    		end
    	end
    	#--------------------------------------------------------------------------
    	def enemy_book_max
    		return $game_temp.enemy_book_data.id_data.size - 1
    	end
    	#--------------------------------------------------------------------------
    	def enemy_book_now
    		now_enemy_info = @enemy_info.keys
    		no_add = $game_temp.enemy_book_data.no_add_element
    		new_enemy_info = []
    		for i in now_enemy_info
    			enemy = $data_enemies[i]
    			next if enemy.name == ""
    			if enemy.element_ranks[no_add] == 1
    				next
    			end
    			new_enemy_info.push(enemy.id)
    		end
    		return new_enemy_info.size
    	end
    	#--------------------------------------------------------------------------
    	def enemy_book_complete_percentage
    		e_max = enemy_book_max.to_f
    		e_now = enemy_book_now.to_f
    		comp = e_now / e_max * 100
    		return comp.truncate
    	end
    end
    
    class Interpreter
    	def enemy_book_max
    		return $game_party.enemy_book_max
    	end
    	def enemy_book_now
    		return $game_party.enemy_book_now
    	end
    	def enemy_book_comp
    		return $game_party.enemy_book_complete_percentage
    	end
    end
    
    class Scene_Battle
    	alias add_enemy_info_start_phase5 start_phase5
    	def start_phase5
    		for enemy in $game_troop.enemies
    			unless enemy.hidden
    				$game_party.add_enemy_info(enemy.id, 0)
    			end
    		end
    		add_enemy_info_start_phase5
    	end
    end
    
    class Window_Base < Window
    	
    	def initialize(x, y, width, height)
    		super()
    		self.contents = Bitmap.new(width - 32, height - 32)
    		self.contents.font.name = $fontface
    		@windowskin_name = $game_system.windowskin_name
    		self.windowskin = RPG::Cache.windowskin(@windowskin_name)
    		self.x = x
    		self.y = y
    		self.width = width
    		self.height = height
    		self.z = 100
    	end
    	#--------------------------------------------------------------------------
    	def draw_enemy_drop_item(enemy, x, y)
    		self.contents.font.color = normal_color
    		self.contents.font.name = $fontface
    		treasures = []
    		if enemy.item_id > 0
    			treasures.push($data_items[enemy.item_id])
    		end
    		if enemy.weapon_id > 0
    			treasures.push($data_weapons[enemy.weapon_id])
    		end
    		if enemy.armor_id > 0
    			treasures.push($data_armors[enemy.armor_id])
    		end
    		if treasures.size > 0
    			item = treasures[0]
    			bitmap = RPG::Cache.icon(item.icon_name)
    			opacity = 255
    			self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
    			name = treasures[0].name
    		else
    			self.contents.font.color = disabled_color
    			self.contents.font.name = $fontface
    			name = "No Item"
    		end
    		self.contents.draw_text(x+28, y, 212, 32, name)
    	end
    	#--------------------------------------------------------------------------
    	def draw_enemy_book_id(enemy, x, y)
    		self.contents.font.color = normal_color
    		self.contents.font.name = $fontface
    		id = $game_temp.enemy_book_data.id_data.index(enemy.id)
    		self.contents.draw_text(x, y, 32, 32, id.to_s)
    	end
    	#--------------------------------------------------------------------------
    	def draw_enemy_name(enemy, x, y)
    		self.contents.font.color = normal_color
    		self.contents.font.name = $fontface
    		self.contents.draw_text(x, y, 152, 32, enemy.name)
    	end
    	#--------------------------------------------------------------------------
    	def draw_enemy_graphic(enemy, x, y, opacity = 255)
    		bitmap = RPG::Cache.battler(enemy.battler_name, enemy.battler_hue)
    		cw = bitmap.width
    		ch = bitmap.height
    		src_rect = Rect.new(0, 0, cw, ch)
    		x = x + (cw / 2 - x) if cw / 2 > x
    		self.contents.blt(x - cw / 2, y - ch, bitmap, src_rect, opacity)
    	end
    	#--------------------------------------------------------------------------
    	def draw_enemy_exp(enemy, x, y)
    		self.contents.font.color = system_color
    		self.contents.font.name = $fontface
    		self.contents.draw_text(x, y, 120, 32, "EXP")
    		self.contents.font.color = normal_color
    		self.contents.font.name = $fontface
    		self.contents.draw_text(x + 120, y, 36, 32, enemy.exp.to_s, 2)
    	end
    	#--------------------------------------------------------------------------
    	def draw_enemy_gold(enemy, x, y)
    		self.contents.font.color = system_color
    		self.contents.font.name = $fontface
    		self.contents.draw_text(x, y, 120, 32, $data_system.words.gold)
    		self.contents.font.color = normal_color
    		self.contents.font.name = $fontface
    		self.contents.draw_text(x + 120, y, 36, 32, enemy.gold.to_s, 2)
    	end
    end
    
    class Game_Enemy_Book < Game_Enemy
    	#--------------------------------------------------------------------------
    	def initialize(enemy_id)
    		super(2, 1)
    		@enemy_id = enemy_id
    		enemy = $data_enemies[@enemy_id]
    		@battler_name = enemy.battler_name
    		@battler_hue = enemy.battler_hue
    		@hp = maxhp
    		@sp = maxsp
    	end
    end
    
    class Data_MonsterBook
    	attr_reader :id_data
    	#--------------------------------------------------------------------------
    	def initialize
    		@id_data = enemy_book_id_set
    	end
    	#--------------------------------------------------------------------------
    	def no_add_element
    		no_add = 0
    		for i in 1...$data_system.elements.size
    			if $data_system.elements[i] =~ /Monster Book/
    				no_add = i
    				break
    			end
    		end
    		return no_add
    	end
    	#--------------------------------------------------------------------------
    	def enemy_book_id_set
    		data = [0]
    		no_add = no_add_element
    		for i in 1...$data_enemies.size
    			enemy = $data_enemies[i]
    			next if enemy.name == ""
    			if enemy.element_ranks[no_add] == 1
    				next
    			end
    			data.push(enemy.id)
    		end
    		return data
    	end
    end
    
    
    class Window_MonsterBook < Window_Selectable
    	attr_reader :data
    	#--------------------------------------------------------------------------
    	def initialize(index=0)
    		super(0, 64, 640, 416)
    		@column_max = 2
    		@book_data = $game_temp.enemy_book_data
    		@data = @book_data.id_data.dup
    		@data.shift
    		@item_max = @data.size
    		self.index = 0
    		refresh if @item_max > 0
    	end
    	#--------------------------------------------------------------------------
    	def data_set
    		data = $game_party.enemy_info.keys
    		data.sort!
    		newdata = []
    		for i in data
    			next if $game_party.enemy_info[i] == 0
    			if book_id(i) != nil
    				newdata.push(i)
    			end
    		end
    		return newdata
    	end
    	#--------------------------------------------------------------------------
    	def show?(id)
    		if $game_party.enemy_info[id] == 0 or $game_party.enemy_info[id] == nil
    			return false
    		else
    			return true
    		end
    	end
    	#--------------------------------------------------------------------------
    	def book_id(id)
    		return @book_data.index(id)
    	end
    	#--------------------------------------------------------------------------
    	def item
    		return @data[self.index]
    	end
    	#--------------------------------------------------------------------------
    	def refresh
    		if self.contents != nil
    			self.contents.dispose
    			self.contents = nil
    		end
    		self.contents = Bitmap.new(width - 32, row_max * 32)
    		if @item_max > 0
    			for i in 0...@item_max
    				draw_item(i)
    			end
    		end
    	end
    	#--------------------------------------------------------------------------
    	def draw_item(index)
    		enemy = $data_enemies[@data[index]]
    		return if enemy == nil
    		x = 4 + index % 2 * (288 + 32)
    		y = index / 2 * 32
    		rect = Rect.new(x, y, self.width / @column_max - 32, 32)
    		self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    		self.contents.font.color = normal_color
    		self.contents.font.name = $fontface
    		draw_enemy_book_id(enemy, x, y)
    		if show?(enemy.id)
    			self.contents.draw_text(x + 28+16, y, 212, 32, enemy.name, 0)
    		else
    			self.contents.draw_text(x + 28+16, y, 212, 32, "-----", 0)
    			return
    		end
    		if analyze?(@data[index])
    			self.contents.font.color = text_color(3)
    			self.contents.font.name = $fontface
    			self.contents.draw_text(x + 256, y, 24, 32, "Cancel", 2)
    		end
    	end
    	#--------------------------------------------------------------------------
    	def analyze?(enemy_id)
    		if $game_party.enemy_info[enemy_id] == 2
    			return true
    		else
    			return false
    		end
    	end
    end
    
    
    class Window_MonsterBook_Info < Window_Base
    	include Enemy_Book_Config
    	#--------------------------------------------------------------------------
    	def initialize
    		super(0, 0+64, 640, 480-64)
    		self.contents = Bitmap.new(width - 32, height - 32)
    	end
    	#--------------------------------------------------------------------------
    	def refresh(enemy_id)
    		self.contents.clear
    		self.contents.font.name = $fontface
    		self.contents.font.size = 22
    		enemy = Game_Enemy_Book.new(enemy_id)
    		draw_enemy_graphic(enemy, 96, 240+48+64, 200)
    		draw_enemy_book_id(enemy, 4, 0)
    		draw_enemy_name(enemy, 48, 0)
    		draw_actor_hp(enemy, 288, 0)
    		draw_actor_sp(enemy, 288+160, 0)
    		draw_actor_parameter(enemy, 288 , 32, 0)
    		self.contents.font.color = system_color
    		self.contents.draw_text(288+160, 32, 120, 32, EVA_NAME)
    		self.contents.font.color = normal_color
    		self.contents.draw_text(288+160 + 120, 32, 36, 32, enemy.eva.to_s, 2)
    		draw_actor_parameter(enemy, 288 , 64, 3)
    		draw_actor_parameter(enemy, 288+160, 64, 4)
    		draw_actor_parameter(enemy, 288 , 96, 5)
    		draw_actor_parameter(enemy, 288+160, 96, 6)
    		draw_actor_parameter(enemy, 288 , 128, 1)
    		draw_actor_parameter(enemy, 288+160, 128, 2)
    		draw_enemy_exp(enemy, 288, 160)
    		draw_enemy_gold(enemy, 288+160, 160)
    		if analyze?(enemy.id) or !DROP_ITEM_NEED_ANALYZE
    			self.contents.draw_text(288, 192, 96, 32, "Drop Item")
    			draw_enemy_drop_item(enemy, 288+96+4, 192)
    			self.contents.font.color = normal_color
    		end
    	end
    	#--------------------------------------------------------------------------
    	def analyze?(enemy_id)
    		if $game_party.enemy_info[enemy_id] == 2
    			return true
    		else
    			return false
    		end
    	end
    end
    
    
    class Scene_MonsterBook
    	include Enemy_Book_Config
    	#--------------------------------------------------------------------------
    	def main
    		$game_temp.enemy_book_data = Data_MonsterBook.new
    		@title_window = Window_Base.new(0, 0, 640, 64)
    		@title_window.contents = Bitmap.new(640 - 32, 64 - 32)
    		@title_window.contents.draw_text(4, 0, 320, 32, "Monster Book", 0)
    		if SHOW_COMPLETE_TYPE != 0
    			case SHOW_COMPLETE_TYPE
    			when 1
    				e_now = $game_party.enemy_book_now
    				e_max = $game_party.enemy_book_max
    				text = e_now.to_s + "/" + e_max.to_s
    			when 2
    				comp = $game_party.enemy_book_complete_percentage
    				text = comp.to_s + "%"
    			when 3
    				e_now = $game_party.enemy_book_now
    				e_max = $game_party.enemy_book_max
    				comp = $game_party.enemy_book_complete_percentage
    				text = e_now.to_s + "/" + e_max.to_s + " " + comp.to_s + "%"
    			end
    			if text != nil
    				@title_window.contents.draw_text(320, 0, 288, 32, text, 2)
    			end
    		end
    		@main_window = Window_MonsterBook.new
    		@main_window.active = true
    		@info_window = Window_MonsterBook_Info.new
    		@info_window.z = 110
    		@info_window.visible = false
    		@info_window.active = false
    		@visible_index = 0
    		Graphics.transition
    		loop do
    			Graphics.update
    			Input.update
    			update
    			if $scene != self
    				break
    			end
    		end
    		Graphics.freeze
    		@main_window.dispose
    		@info_window.dispose
    		@title_window.dispose
    	end
    	#--------------------------------------------------------------------------
    	def update
    		@main_window.update
    		@info_window.update
    		if @info_window.active
    			update_info
    			return
    		end
    		if @main_window.active
    			update_main
    			return
    		end
    	end
    	#--------------------------------------------------------------------------
    	def update_main
    		if Input.trigger?(Input::C)
    			$game_system.se_play($data_system.cancel_se)
    			$scene = Scene_Map.new
    			return
    		end
    		if Input.trigger?(Input::C)
    			if @main_window.item == nil or @main_window.show?(@main_window.item) == false
    				$game_system.se_play($data_system.buzzer_se)
    				return
    			end
    			$game_system.se_play($data_system.decision_se)
    			@main_window.active = false
    			@info_window.active = true
    			@info_window.visible = true
    			@visible_index = @main_window.index
    			@info_window.refresh(@main_window.item)
    			return
    		end
    	end
    	#--------------------------------------------------------------------------
    	def update_info
    		if Input.trigger?(Input::C)
    			$game_system.se_play($data_system.cancel_se)
    			@main_window.active = true
    			@info_window.active = false
    			@info_window.visible = false
    			return
    		end
    		if Input.trigger?(Input::C)
    			return
    		end
    		if Input.trigger?(Input::L)
    			$game_system.se_play($data_system.decision_se)
    			loop_end = false
    			while loop_end == false
    			if @visible_index != 0
    				@visible_index -= 1
    			else
    				@visible_index = @main_window.data.size - 1
    			end
    			loop_end = true if @main_window.show?(@main_window.data[@visible_index])
    		end
    		id = @main_window.data[@visible_index]
    		@info_window.refresh(id)
    		return
    	end
    	if Input.trigger?(Input::C)
    		$game_system.se_play($data_system.decision_se)
    		loop_end = false
    		while loop_end == false
    		if @visible_index != @main_window.data.size - 1
    			@visible_index += 1
    		else
    			@visible_index = 0
    		end
    		loop_end = true if @main_window.show?(@main_window.data[@visible_index])
    	end
    	id = @main_window.data[@visible_index]
    	@info_window.refresh(id)
    	return
    end
    end
    end
    
    

     

     



    il cdice da mettere per attivare il bestiario ? questo, sempre da mettere nel system con gli eventi comuni

    $scene = Scene_MonsterBook.new

    aiuto plz

  2. inftti ho ftt così ma ho 2 domande:

     

    1 lo script $game_screen.weather(0, 50, 0). lo devo mettere in un evento del database>oppure metterlo in mezzo alla mappa

     

    2 quando metto l'evento nella mappa mi dice error systemexxor o come dice senza n numero e se lo metto nel databse nn mi accade nnt quindi iv prg XXD aiuto

  3. scusate ancora il disturbo ma girando ho trovato anche lo script atmosferico :blink: però il problema è che nn funziona plz aiutatemi:

     

    QUESTO è LO SCRIPT

     

     

    #===========================
    # ccoa's weather script
    # with ideas by ScriptKitty and Mr.DJ
    #===========================
    # Weather Types:
    # 1 - rain
    # 2 - storm
    # 3 - snow
    # 4 - hail
    # 5 - rain with thunder and lightning
    # 6 - falling leaves (autumn)
    # 7 - blowing leaves (autumn)
    # 8 - swirling leaves (autumn)
    # 9 - falling leaves (green)
    # 10 - cherry blossom (sakura) petals
    # 11 - rose petals
    # 12 - feathers
    # 13 - blood rain
    # 14 - sparkles
    # 15 - user defined
    # 16 - piogia di scintille
    #
    # Weather Power:
    # An integer from 0-40. 0 = no weather, 40 = 400 sprites
    #
    # Usage:
    # Create a call script with the following:
    # $game_screen.weather(type, power, hue)
    #
    # Usage of user-defined weather:
    # Look at the following globals:
    
    $WEATHER_UPDATE = false # the $WEATHER_IMAGES array has changed, please update
    $WEATHER_IMAGES = [] # the array of picture names to use
    $WEATHER_X = 0 # the number of pixels the image should move horizontally (positive = right, negative = left)
    $WEATHER_Y = 0 # the number of pizels the image should move vertically (positive = down, negative = up)
    $WEATHER_FADE = 0 # how much the image should fade each update (0 = no fade, 255 = fade instantly)
    $WEATHER_ANIMATED = false # whether or not the image should cycle through all the images
    
    module RPG
    class Weather
    def initialize(viewport = nil)
    @type = 0
    @max = 0
    @ox = 0
    @oy = 0
    @count = 0
    @current_pose = []
    @info = []
    @countarray = []
    
    make_bitmaps
    
    # **** ccoa ****
    for i in 1..500
    sprite = Sprite.new(viewport)
    sprite.z = 1000
    sprite.visible = false
    sprite.opacity = 0
    @sprites.push(sprite)
    @current_pose.push(0)
    @info.push(rand(50))
    @countarray.push(rand(15))
    end
    end
    
    def dispose
    for sprite in @sprites
    sprite.dispose
    end
    @rain_bitmap.dispose
    @storm_bitmap.dispose
    @snow_bitmap.dispose
    @hail_bitmap.dispose
    @petal_bitmap.dispose
    @blood_rain_bitmap.dispose
    for image in @autumn_leaf_bitmaps
    image.dispose
    end
    for image in @green_leaf_bitmaps
    image.dispose
    end
    for image in @rose_bitmaps
    image.dispose
    end
    for image in @feather_bitmaps
    image.dispose
    end
    for image in @sparkle_bitmaps
    image.dispose
    end
    for image in @user_bitmaps
    image.dispose
    end
    $WEATHER_UPDATE = true
    end
    
    def type=(type)
    return if @type == type
    @type = type
    case @type
    when 1 # rain
    bitmap = @rain_bitmap
    when 2 # storm
    bitmap = @storm_bitmap
    when 3 # snow
    bitmap = @snow_bitmap
    when 4 # hail
    bitmap = @hail_bitmap
    when 5 # rain w/ thunder and lightning
    bitmap = @rain_bitmap
    @thunder = true
    when 6 # falling autumn leaves
    bitmap = @autumn_leaf_bitmaps[0]
    when 7 # blowing autumn leaves
    bitmap = @autumn_leaf_bitmaps[0]
    when 8 # swirling autumn leaves
    bitmap = @autumn_leaf_bitmaps[0]
    when 9 # falling green leaves
    bitmap = @green_leaf_bitmaps[0]
    when 10 # sakura petals
    bitmap = @petal_bitmap
    when 11 # rose petals
    bitmap = @rose_bitmaps[0]
    when 12 # feathers
    bitmap = @feather_bitmaps[0]
    when 13 # blood rain
    bitmap = @blood_rain_bitmap
    when 14 # sparkles
    bitmap = @sparkle_bitmaps[0]
    when 15 # user-defined
    bitmap = @user_bitmaps[rand(@user_bitmaps.size)]
    when 16 # scintille
    bitmap = @scintille_bitmap
    else
    bitmap = nil
    end
    if @type != 5
    @thunder = false
    end
    # **** ccoa ****
    for i in 1..500
    sprite = @sprites[i]
    if sprite != nil
    sprite.visible = (i <= @max)
    sprite.bitmap = bitmap
    end
    end
    end
    
    def ox=(ox)
    return if @ox == ox;
    @ox = ox
    for sprite in @sprites
    sprite.ox = @ox
    end
    end
    
    def oy=(oy)
    return if @oy == oy;
    @oy = oy
    for sprite in @sprites
    sprite.oy = @oy
    end
    end
    
    def max=(max)
    return if @max == max;
    # **** ccoa ****
    @max = [[max, 0].max, 500].min
    for i in 1..500
    sprite = @sprites[i]
    if sprite != nil
    sprite.visible = (i <= @max)
    end
    end
    end
    
    def update
    return if @type == 0
    for i in 1..@max
    sprite = @sprites[i]
    if sprite == nil
    break
    end
    if @type == 1 or @type == 5 or @type == 13 # rain
    sprite.x -= 2
    sprite.y += 16
    sprite.opacity -= 8
    if @thunder and (rand(8000 - @max) == 0)
    $game_screen.start_flash(Color.new(255, 255, 255, 255), 5)
    Audio.se_play("Audio/SE/061-Thunderclap01")
    end
    end
    if @type == 2 # storm
    sprite.x -= 8
    sprite.y += 16
    sprite.opacity -= 12
    end
    if @type == 3 # snow
    sprite.x -= 2
    sprite.y += 8
    sprite.opacity -= 8
    end
    if @type == 4 # hail
    sprite.x -= 1
    sprite.y += 18
    sprite.opacity -= 15
    end
    if @type == 6 # falling autumn leaves
    @count = rand(20)
    if @count == 0
    sprite.bitmap = @autumn_leaf_bitmaps[@current_pose[i]]
    @current_pose[i] = (@current_pose[i] + 1) % @autumn_leaf_bitmaps.size
    end
    sprite.x -= 1
    sprite.y += 1
    end
    if @type == 7 # blowing autumn leaves
    @count = rand(20)
    if @count == 0
    sprite.bitmap = @autumn_leaf_bitmaps[@current_pose[i]]
    @current_pose[i] = (@current_pose[i] + 1) % @autumn_leaf_bitmaps.size
    end
    sprite.x -= 10
    sprite.y += (rand(4) - 2)
    end
    if @type == 8 # swirling autumn leaves
    @count = rand(20)
    if @count == 0
    sprite.bitmap = @autumn_leaf_bitmaps[@current_pose[i]]
    @current_pose[i] = (@current_pose[i] + 1) % @autumn_leaf_bitmaps.size
    end
    if @info[i] != 0
    if @info[i] >= 1 and @info[i] <= 10
    sprite.x -= 3
    sprite.y -= 1
    elsif @info[i] >= 11 and @info[i] <= 16
    sprite.x -= 1
    sprite.y -= 2
    elsif @info[i] >= 17 and @info[i] <= 20
    sprite.y -= 3
    elsif @info[i] >= 21 and @info[i] <= 30
    sprite.y -= 2
    sprite.x += 1
    elsif @info[i] >= 31 and @info[i] <= 36
    sprite.y -= 1
    sprite.x += 3
    elsif @info[i] >= 37 and @info[i] <= 40
    sprite.x += 5
    elsif @info[i] >= 41 and @info[i] <= 46
    sprite.y += 1
    sprite.x += 3
    elsif @info[i] >= 47 and @info[i] <= 58
    sprite.y += 2
    sprite.x += 1
    elsif @info[i] >= 59 and @info[i] <= 64
    sprite.y += 3
    elsif @info[i] >= 65 and @info[i] <= 70
    sprite.x -= 1
    sprite.y += 2
    elsif @info[i] >= 71 and @info[i] <= 81
    sprite.x -= 3
    sprite.y += 1
    elsif @info[i] >= 82 and @info[i] <= 87
    sprite.x -= 5
    end
    @info[i] = (@info[i] + 1) % 88
    else
    if rand(200) == 0
    @info[i] = 1
    end
    sprite.x -= 5
    sprite.y += 1
    end
    end
    if @type == 9 # falling green leaves
    if @countarray[i] == 0
    @current_pose[i] = (@current_pose[i] + 1) % @green_leaf_bitmaps.size
    sprite.bitmap = @green_leaf_bitmaps[@current_pose[i]]
    @countarray[i] = rand(15)
    end
    @countarray[i] = (@countarray[i] + 1) % 15
    sprite.y += 1
    end
    if @type == 10 # sakura petals
    if @info[i] < 25
    sprite.x -= 1
    else
    sprite.x += 1
    end
    @info[i] = (@info[i] + 1) % 50
    sprite.y += 1
    end
    if @type == 11 # rose petals
    @count = rand(20)
    if @count == 0
    sprite.bitmap = @rose_bitmaps[@current_pose[i]]
    @current_pose[i] = (@current_pose[i] + 1) % @rose_bitmaps.size
    end
    if @info[i] % 2 == 0
    if @info[i] < 10
    sprite.x -= 1
    else
    sprite.x += 1
    end
    end
    sprite.y += 1
    end
    if @type == 12 # feathers
    if @countarray[i] == 0
    @current_pose[i] = (@current_pose[i] + 1) % @feather_bitmaps.size
    sprite.bitmap = @feather_bitmaps[@current_pose[i]]
    end
    @countarray[i] = (@countarray[i] + 1) % 15
    if rand(100) == 0
    sprite.x -= 1
    end
    if rand(100) == 0
    sprite.y -= 1
    end
    if @info[i] < 50
    if rand(2) == 0
    sprite.x -= 1
    else
    sprite.y -= 1
    end
    else
    if rand(2) == 0
    sprite.x += 1
    else
    sprite.y += 1
    end
    end
    @info[i] = (@info[i] + 1) % 100
    end
    if @type == 14 # sparkles
    if @countarray[i] == 0
    @current_pose[i] = (@current_pose[i] + 1) % @sparkle_bitmaps.size
    sprite.bitmap = @sparkle_bitmaps[@current_pose[i]]
    end
    @countarray[i] = (@countarray[i] + 1) % 15
    sprite.y += 1
    sprite.opacity -= 1
    end
    if @type == 16 # scintille
    sprite.x -= 10
    sprite.y += -2
    sprite.opacity -= 12
    end
    if @type == 15 # user-defined
    if $WEATHER_UPDATE
    update_user_defined
    $WEATHER_UPDATE = false
    end
    if $WEATHER_ANIMATED and @countarray[i] == 0
    @current_pose[i] = (@current_pose[i] + 1) % @user_bitmaps.size
    sprite.bitmap = @user_bitmaps[@current_pose[i]]
    end
    @countarray[i] = (@countarray[i] + 1) % 15
    sprite.x += $WEATHER_X
    sprite.y += $WEATHER_Y
    sprite.opacity -= $WEATHER_FADE
    end
    
    x = sprite.x - @ox
    y = sprite.y - @oy
    if sprite.opacity < 64 or x < -50 or x > 750 or y < -300 or y > 500
    sprite.x = rand(800) - 50 + @ox
    sprite.y = rand(800) - 200 + @oy
    sprite.opacity = 255
    end
    end
    end
    
    def make_bitmaps
    color1 = Color.new(255, 255, 255, 255)
    color2 = Color.new(255, 255, 255, 128)
    @rain_bitmap = Bitmap.new(7, 56)
    for i in 0..6
    @rain_bitmap.fill_rect(6-i, i*8, 1, 8, color1)
    end
    @storm_bitmap = Bitmap.new(34, 64)
    for i in 0..31
    @storm_bitmap.fill_rect(33-i, i*2, 1, 2, color2)
    @storm_bitmap.fill_rect(32-i, i*2, 1, 2, color1)
    @storm_bitmap.fill_rect(31-i, i*2, 1, 2, color2)
    end
    @snow_bitmap = Bitmap.new(6, 6)
    @snow_bitmap.fill_rect(0, 1, 6, 4, color2)
    @snow_bitmap.fill_rect(1, 0, 4, 6, color2)
    @snow_bitmap.fill_rect(1, 2, 4, 2, color1)
    @snow_bitmap.fill_rect(2, 1, 2, 4, color1)
    @sprites = []
    
    brightOrange = Color.new(248, 88, 0, 255)
    brightRed = Color.new(255, 0, 0, 255)
    midRed = Color.new(179, 17, 17, 255)
    yellow = Color.new(255, 255, 0, 255)
    @scintille_bitmap = Bitmap.new(3, 3)
    @scintille_bitmap.fill_rect(0, 1, 3, 2, brightOrange)
    @scintille_bitmap.fill_rect(1, 0, 2, 3, yellow)
    @scintille_bitmap.fill_rect(1, 1, 2, 3, brightRed)
    @scintille_bitmap.fill_rect(1, 1, 1, 2, brightOrange)
    @sprites = []
    
    blueGrey = Color.new(215, 227, 227, 150)
    grey = Color.new(214, 217, 217, 150)
    lightGrey = Color.new(233, 233, 233, 250)
    lightBlue = Color.new(222, 239, 243, 250)
    @hail_bitmap = Bitmap.new(4, 4)
    @hail_bitmap.fill_rect(1, 0, 2, 1, blueGrey)
    @hail_bitmap.fill_rect(0, 1, 1, 2, blueGrey)
    @hail_bitmap.fill_rect(3, 1, 1, 2, grey)
    @hail_bitmap.fill_rect(1, 3, 2, 1, grey)
    @hail_bitmap.fill_rect(1, 1, 2, 2, lightGrey)
    @hail_bitmap.set_pixel(1, 1, lightBlue)
    
    
    color3 = Color.new(255, 167, 192, 255) # light pink
    color4 = Color.new(213, 106, 136, 255) # dark pink
    @petal_bitmap = Bitmap.new(4, 4) #This creates a new bitmap that is 4 x 4 pixels
    @petal_bitmap.fill_rect(0, 3, 1, 1, color3) # this makes a 1x1 pixel "rectangle" at the 0, 3 pixel of the image (upper left corner is 0, 0)
    @petal_bitmap.fill_rect(1, 2, 1, 1, color3)
    @petal_bitmap.fill_rect(2, 1, 1, 1, color3)
    @petal_bitmap.fill_rect(3, 0, 1, 1, color3)
    @petal_bitmap.fill_rect(1, 3, 1, 1, color4)
    @petal_bitmap.fill_rect(2, 2, 1, 1, color4)
    @petal_bitmap.fill_rect(3, 1, 1, 1, color4)
    
    
    brightOrange = Color.new(248, 88, 0, 255)
    orangeBrown = Color.new(144, 80, 56, 255)
    burntRed = Color.new(152, 0, 0, 255)
    paleOrange = Color.new(232, 160, 128, 255)
    darkBrown = Color.new(72, 40, 0, 255)
    @autumn_leaf_bitmaps = []
    @autumn_leaf_bitmaps.push(Bitmap.new(8, 8))
    # draw the first of the leaf1 bitmaps
    @autumn_leaf_bitmaps[0].set_pixel(5, 1, orangeBrown)
    @autumn_leaf_bitmaps[0].set_pixel(6, 1, brightOrange)
    @autumn_leaf_bitmaps[0].set_pixel(7, 1, paleOrange)
    @autumn_leaf_bitmaps[0].set_pixel(3, 2, orangeBrown)
    @autumn_leaf_bitmaps[0].fill_rect(4, 2, 2, 1, brightOrange)
    @autumn_leaf_bitmaps[0].set_pixel(6, 2, paleOrange)
    @autumn_leaf_bitmaps[0].set_pixel(2, 3, orangeBrown)
    @autumn_leaf_bitmaps[0].set_pixel(3, 3, brightOrange)
    @autumn_leaf_bitmaps[0].fill_rect(4, 3, 2, 1, paleOrange)
    @autumn_leaf_bitmaps[0].set_pixel(1, 4, orangeBrown)
    @autumn_leaf_bitmaps[0].set_pixel(2, 4, brightOrange)
    @autumn_leaf_bitmaps[0].set_pixel(3, 4, paleOrange)
    @autumn_leaf_bitmaps[0].set_pixel(1, 5, brightOrange)
    @autumn_leaf_bitmaps[0].set_pixel(2, 5, paleOrange)
    @autumn_leaf_bitmaps[0].set_pixel(0, 6, orangeBrown)
    @autumn_leaf_bitmaps[0].set_pixel(1, 6, paleOrange)
    @autumn_leaf_bitmaps[0].set_pixel(0, 7, paleOrange)
    
    # draw the 2nd of the leaf1 bitmaps
    @autumn_leaf_bitmaps.push(Bitmap.new(8, 8))
    @autumn_leaf_bitmaps[1].set_pixel(3, 0, brightOrange)
    @autumn_leaf_bitmaps[1].set_pixel(7, 0, brightOrange)
    @autumn_leaf_bitmaps[1].set_pixel(3, 1, orangeBrown)
    @autumn_leaf_bitmaps[1].set_pixel(4, 1, burntRed)
    @autumn_leaf_bitmaps[1].set_pixel(6, 1, brightOrange)
    @autumn_leaf_bitmaps[1].set_pixel(0, 2, paleOrange)
    @autumn_leaf_bitmaps[1].set_pixel(1, 2, brightOrange)
    @autumn_leaf_bitmaps[1].set_pixel(2, 2, orangeBrown)
    @autumn_leaf_bitmaps[1].set_pixel(3, 2, burntRed)
    @autumn_leaf_bitmaps[1].set_pixel(4, 2, orangeBrown)
    @autumn_leaf_bitmaps[1].set_pixel(5, 2, brightOrange)
    @autumn_leaf_bitmaps[1].fill_rect(1, 3, 3, 1, orangeBrown)
    @autumn_leaf_bitmaps[1].fill_rect(4, 3, 2, 1, brightOrange)
    @autumn_leaf_bitmaps[1].set_pixel(6, 3, orangeBrown)
    @autumn_leaf_bitmaps[1].set_pixel(2, 4, burntRed)
    @autumn_leaf_bitmaps[1].fill_rect(3, 4, 3, 1, brightOrange)
    @autumn_leaf_bitmaps[1].set_pixel(6, 4, burntRed)
    @autumn_leaf_bitmaps[1].set_pixel(7, 4, darkBrown)
    @autumn_leaf_bitmaps[1].set_pixel(1, 5, orangeBrown)
    @autumn_leaf_bitmaps[1].fill_rect(2, 5, 2, 1, brightOrange)
    @autumn_leaf_bitmaps[1].set_pixel(4, 5, orangeBrown)
    @autumn_leaf_bitmaps[1].set_pixel(5, 5, burntRed)
    @autumn_leaf_bitmaps[1].fill_rect(1, 6, 2, 1, brightOrange)
    @autumn_leaf_bitmaps[1].fill_rect(4, 6, 2, 1, burntRed)
    @autumn_leaf_bitmaps[1].set_pixel(0, 7, brightOrange)
    @autumn_leaf_bitmaps[1].set_pixel(5, 7, darkBrown)
    
    # draw the 3rd of the leaf1 bitmaps
    @autumn_leaf_bitmaps.push(Bitmap.new(8, 8))
    @autumn_leaf_bitmaps[2].set_pixel(7, 1, paleOrange)
    @autumn_leaf_bitmaps[2].set_pixel(6, 2, paleOrange)
    @autumn_leaf_bitmaps[2].set_pixel(7, 2, orangeBrown)
    @autumn_leaf_bitmaps[2].set_pixel(5, 3, paleOrange)
    @autumn_leaf_bitmaps[2].set_pixel(6, 3, brightOrange)
    @autumn_leaf_bitmaps[2].set_pixel(4, 4, paleOrange)
    @autumn_leaf_bitmaps[2].set_pixel(5, 4, brightOrange)
    @autumn_leaf_bitmaps[2].set_pixel(6, 4, orangeBrown)
    @autumn_leaf_bitmaps[2].fill_rect(2, 5, 2, 1, paleOrange)
    @autumn_leaf_bitmaps[2].set_pixel(4, 5, brightOrange)
    @autumn_leaf_bitmaps[2].set_pixel(5, 5, orangeBrown)
    @autumn_leaf_bitmaps[2].set_pixel(1, 6, paleOrange)
    @autumn_leaf_bitmaps[2].fill_rect(2, 6, 2, 1, brightOrange)
    @autumn_leaf_bitmaps[2].set_pixel(4, 6, orangeBrown)
    @autumn_leaf_bitmaps[2].set_pixel(0, 7, paleOrange)
    @autumn_leaf_bitmaps[2].set_pixel(1, 7, brightOrange)
    @autumn_leaf_bitmaps[2].set_pixel(2, 7, orangeBrown)
    
    # draw the 4th of the leaf1 bitmaps
    @autumn_leaf_bitmaps.push(Bitmap.new(8, 8))
    @autumn_leaf_bitmaps[3].set_pixel(3, 0, brightOrange)
    @autumn_leaf_bitmaps[3].set_pixel(7, 0, brightOrange)
    @autumn_leaf_bitmaps[3].set_pixel(3, 1, orangeBrown)
    @autumn_leaf_bitmaps[3].set_pixel(4, 1, burntRed)
    @autumn_leaf_bitmaps[3].set_pixel(6, 1, brightOrange)
    @autumn_leaf_bitmaps[3].set_pixel(0, 2, paleOrange)
    @autumn_leaf_bitmaps[3].set_pixel(1, 2, brightOrange)
    @autumn_leaf_bitmaps[3].set_pixel(2, 2, orangeBrown)
    @autumn_leaf_bitmaps[3].set_pixel(3, 2, burntRed)
    @autumn_leaf_bitmaps[3].set_pixel(4, 2, orangeBrown)
    @autumn_leaf_bitmaps[3].set_pixel(5, 2, brightOrange)
    @autumn_leaf_bitmaps[3].fill_rect(1, 3, 3, 1, orangeBrown)
    @autumn_leaf_bitmaps[3].fill_rect(4, 3, 2, 1, brightOrange)
    @autumn_leaf_bitmaps[3].set_pixel(6, 3, orangeBrown)
    @autumn_leaf_bitmaps[3].set_pixel(2, 4, burntRed)
    @autumn_leaf_bitmaps[3].fill_rect(3, 4, 3, 1, brightOrange)
    @autumn_leaf_bitmaps[3].set_pixel(6, 4, burntRed)
    @autumn_leaf_bitmaps[3].set_pixel(7, 4, darkBrown)
    @autumn_leaf_bitmaps[3].set_pixel(1, 5, orangeBrown)
    @autumn_leaf_bitmaps[3].fill_rect(2, 5, 2, 1, brightOrange)
    @autumn_leaf_bitmaps[3].set_pixel(4, 5, orangeBrown)
    @autumn_leaf_bitmaps[3].set_pixel(5, 5, burntRed)
    @autumn_leaf_bitmaps[3].fill_rect(1, 6, 2, 1, brightOrange)
    @autumn_leaf_bitmaps[3].fill_rect(4, 6, 2, 1, burntRed)
    @autumn_leaf_bitmaps[3].set_pixel(0, 7, brightOrange)
    @autumn_leaf_bitmaps[3].set_pixel(5, 7, darkBrown)
    
    @green_leaf_bitmaps = []
    darkGreen = Color.new(62, 76, 31, 255)
    midGreen = Color.new(76, 91, 43, 255)
    khaki = Color.new(105, 114, 66, 255)
    lightGreen = Color.new(128, 136, 88, 255)
    mint = Color.new(146, 154, 106, 255)
    
    # 1st leaf bitmap
    @green_leaf_bitmaps[0] = Bitmap.new(8, 8)
    @green_leaf_bitmaps[0].set_pixel(1, 0, darkGreen)
    @green_leaf_bitmaps[0].set_pixel(1, 1, midGreen)
    @green_leaf_bitmaps[0].set_pixel(2, 1, darkGreen)
    @green_leaf_bitmaps[0].set_pixel(2, 2, khaki)
    @green_leaf_bitmaps[0].set_pixel(3, 2, darkGreen)
    @green_leaf_bitmaps[0].set_pixel(4, 2, khaki)
    @green_leaf_bitmaps[0].fill_rect(2, 3, 3, 1, midGreen)
    @green_leaf_bitmaps[0].set_pixel(5, 3, khaki)
    @green_leaf_bitmaps[0].fill_rect(2, 4, 2, 1, midGreen)
    @green_leaf_bitmaps[0].set_pixel(4, 4, darkGreen)
    @green_leaf_bitmaps[0].set_pixel(5, 4, lightGreen)
    @green_leaf_bitmaps[0].set_pixel(6, 4, khaki)
    @green_leaf_bitmaps[0].set_pixel(3, 5, midGreen)
    @green_leaf_bitmaps[0].set_pixel(4, 5, darkGreen)
    @green_leaf_bitmaps[0].set_pixel(5, 5, khaki)
    @green_leaf_bitmaps[0].set_pixel(6, 5, lightGreen)
    @green_leaf_bitmaps[0].set_pixel(4, 6, midGreen)
    @green_leaf_bitmaps[0].set_pixel(5, 6, darkGreen)
    @green_leaf_bitmaps[0].set_pixel(6, 6, lightGreen)
    @green_leaf_bitmaps[0].set_pixel(6, 7, khaki)
    
    # 2nd leaf bitmap
    @green_leaf_bitmaps[1] = Bitmap.new(8, 8)
    @green_leaf_bitmaps[1].fill_rect(1, 1, 1, 2, midGreen)
    @green_leaf_bitmaps[1].fill_rect(2, 2, 2, 1, khaki)
    @green_leaf_bitmaps[1].set_pixel(4, 2, lightGreen)
    @green_leaf_bitmaps[1].fill_rect(2, 3, 2, 1, darkGreen)
    @green_leaf_bitmaps[1].fill_rect(4, 3, 2, 1, lightGreen)
    @green_leaf_bitmaps[1].set_pixel(2, 4, midGreen)
    @green_leaf_bitmaps[1].set_pixel(3, 4, darkGreen)
    @green_leaf_bitmaps[1].set_pixel(4, 4, khaki)
    @green_leaf_bitmaps[1].fill_rect(5, 4, 2, 1, lightGreen)
    @green_leaf_bitmaps[1].set_pixel(3, 5, midGreen)
    @green_leaf_bitmaps[1].set_pixel(4, 5, darkGreen)
    @green_leaf_bitmaps[1].set_pixel(5, 5, khaki)
    @green_leaf_bitmaps[1].set_pixel(6, 5, lightGreen)
    @green_leaf_bitmaps[1].set_pixel(5, 6, darkGreen)
    @green_leaf_bitmaps[1].fill_rect(6, 6, 2, 1, khaki)
    
    # 3rd leaf bitmap
    @green_leaf_bitmaps[2] = Bitmap.new(8, 8)
    @green_leaf_bitmaps[2].set_pixel(1, 1, darkGreen)
    @green_leaf_bitmaps[2].fill_rect(1, 2, 2, 1, midGreen)
    @green_leaf_bitmaps[2].set_pixel(2, 3, midGreen)
    @green_leaf_bitmaps[2].set_pixel(3, 3, darkGreen)
    @green_leaf_bitmaps[2].set_pixel(4, 3, midGreen)
    @green_leaf_bitmaps[2].fill_rect(2, 4, 2, 1, midGreen)
    @green_leaf_bitmaps[2].set_pixel(4, 4, darkGreen)
    @green_leaf_bitmaps[2].set_pixel(5, 4, lightGreen)
    @green_leaf_bitmaps[2].set_pixel(3, 5, midGreen)
    @green_leaf_bitmaps[2].set_pixel(4, 5, darkGreen)
    @green_leaf_bitmaps[2].fill_rect(5, 5, 2, 1, khaki)
    @green_leaf_bitmaps[2].fill_rect(4, 6, 2, 1, midGreen)
    @green_leaf_bitmaps[2].set_pixel(6, 6, lightGreen)
    @green_leaf_bitmaps[2].set_pixel(6, 7, khaki)
    
    # 4th leaf bitmap
    @green_leaf_bitmaps[3] = Bitmap.new(8, 8)
    @green_leaf_bitmaps[3].fill_rect(0, 3, 1, 2, darkGreen)
    @green_leaf_bitmaps[3].set_pixel(1, 4, midGreen)
    @green_leaf_bitmaps[3].set_pixel(2, 4, khaki)
    @green_leaf_bitmaps[3].set_pixel(3, 4, lightGreen)
    @green_leaf_bitmaps[3].set_pixel(4, 4, darkGreen)
    @green_leaf_bitmaps[3].set_pixel(7, 4, midGreen)
    @green_leaf_bitmaps[3].set_pixel(1, 5, darkGreen)
    @green_leaf_bitmaps[3].set_pixel(2, 5, midGreen)
    @green_leaf_bitmaps[3].set_pixel(3, 5, lightGreen)
    @green_leaf_bitmaps[3].set_pixel(4, 5, mint)
    @green_leaf_bitmaps[3].set_pixel(5, 5, lightGreen)
    @green_leaf_bitmaps[3].set_pixel(6, 5, khaki)
    @green_leaf_bitmaps[3].set_pixel(7, 5, midGreen)
    @green_leaf_bitmaps[3].fill_rect(2, 6, 2, 1, midGreen)
    @green_leaf_bitmaps[3].set_pixel(4, 6, lightGreen)
    @green_leaf_bitmaps[3].set_pixel(5, 6, khaki)
    @green_leaf_bitmaps[3].set_pixel(6, 6, midGreen)
    
    # 5th leaf bitmap
    @green_leaf_bitmaps[4] = Bitmap.new(8, 8)
    @green_leaf_bitmaps[4].set_pixel(6, 2, midGreen)
    @green_leaf_bitmaps[4].set_pixel(7, 2, darkGreen)
    @green_leaf_bitmaps[4].fill_rect(4, 3, 2, 1, midGreen)
    @green_leaf_bitmaps[4].set_pixel(6, 3, khaki)
    @green_leaf_bitmaps[4].set_pixel(2, 4, darkGreen)
    @green_leaf_bitmaps[4].fill_rect(3, 4, 2, 1, khaki)
    @green_leaf_bitmaps[4].set_pixel(5, 4, lightGreen)
    @green_leaf_bitmaps[4].set_pixel(6, 4, khaki)
    @green_leaf_bitmaps[4].set_pixel(1, 5, midGreen)
    @green_leaf_bitmaps[4].set_pixel(2, 5, khaki)
    @green_leaf_bitmaps[4].set_pixel(3, 5, lightGreen)
    @green_leaf_bitmaps[4].set_pixel(4, 5, mint)
    @green_leaf_bitmaps[4].set_pixel(5, 5, midGreen)
    @green_leaf_bitmaps[4].set_pixel(2, 6, darkGreen)
    @green_leaf_bitmaps[4].fill_rect(3, 6, 2, 1, midGreen)
    
    # 6th leaf bitmap
    @green_leaf_bitmaps[5] = Bitmap.new(8, 8)
    @green_leaf_bitmaps[5].fill_rect(6, 2, 2, 1, midGreen)
    @green_leaf_bitmaps[5].fill_rect(4, 3, 2, 1, midGreen)
    @green_leaf_bitmaps[5].set_pixel(6, 3, khaki)
    @green_leaf_bitmaps[5].set_pixel(3, 4, midGreen)
    @green_leaf_bitmaps[5].set_pixel(4, 4, khaki)
    @green_leaf_bitmaps[5].set_pixel(5, 4, lightGreen)
    @green_leaf_bitmaps[5].set_pixel(6, 4, mint)
    @green_leaf_bitmaps[5].set_pixel(1, 5, midGreen)
    @green_leaf_bitmaps[5].set_pixel(2, 5, khaki)
    @green_leaf_bitmaps[5].fill_rect(3, 5, 2, 1, mint)
    @green_leaf_bitmaps[5].set_pixel(5, 5, lightGreen)
    @green_leaf_bitmaps[5].set_pixel(2, 6, midGreen)
    @green_leaf_bitmaps[5].set_pixel(3, 6, khaki)
    @green_leaf_bitmaps[5].set_pixel(4, 6, lightGreen)
    
    # 7th leaf bitmap
    @green_leaf_bitmaps[6] = Bitmap.new(8, 8)
    @green_leaf_bitmaps[6].fill_rect(6, 1, 1, 2, midGreen)
    @green_leaf_bitmaps[6].fill_rect(4, 2, 2, 1, midGreen)
    @green_leaf_bitmaps[6].fill_rect(6, 2, 1, 2, darkGreen)
    @green_leaf_bitmaps[6].fill_rect(3, 3, 2, 1, midGreen)
    @green_leaf_bitmaps[6].set_pixel(5, 3, khaki)
    @green_leaf_bitmaps[6].set_pixel(2, 4, midGreen)
    @green_leaf_bitmaps[6].set_pixel(3, 4, khaki)
    @green_leaf_bitmaps[6].set_pixel(4, 4, lightGreen)
    @green_leaf_bitmaps[6].set_pixel(5, 4, midGreen)
    @green_leaf_bitmaps[6].set_pixel(1, 5, midGreen)
    @green_leaf_bitmaps[6].set_pixel(2, 5, khaki)
    @green_leaf_bitmaps[6].fill_rect(3, 5, 2, 1, midGreen)
    @green_leaf_bitmaps[6].set_pixel(1, 6, darkGreen)
    @green_leaf_bitmaps[6].set_pixel(2, 6, midGreen)
    
    # 8th leaf bitmap
    @green_leaf_bitmaps[7] = Bitmap.new(8, 8)
    @green_leaf_bitmaps[7].set_pixel(6, 1, midGreen)
    @green_leaf_bitmaps[7].fill_rect(4, 2, 3, 2, midGreen)
    @green_leaf_bitmaps[7].set_pixel(3, 3, darkGreen)
    @green_leaf_bitmaps[7].set_pixel(2, 4, darkGreen)
    @green_leaf_bitmaps[7].set_pixel(3, 4, midGreen)
    @green_leaf_bitmaps[7].fill_rect(4, 4, 2, 1, khaki)
    @green_leaf_bitmaps[7].set_pixel(1, 5, darkGreen)
    @green_leaf_bitmaps[7].set_pixel(2, 5, midGreen)
    @green_leaf_bitmaps[7].fill_rect(3, 5, 2, 1, lightGreen)
    @green_leaf_bitmaps[7].set_pixel(2, 6, midGreen)
    @green_leaf_bitmaps[7].set_pixel(3, 6, lightGreen)
    
    # 9th leaf bitmap
    @green_leaf_bitmaps[8] = Bitmap.new(8, 8)
    @green_leaf_bitmaps[8].fill_rect(6, 1, 1, 2, midGreen)
    @green_leaf_bitmaps[8].fill_rect(4, 2, 2, 1, midGreen)
    @green_leaf_bitmaps[8].fill_rect(6, 2, 1, 2, darkGreen)
    @green_leaf_bitmaps[8].fill_rect(3, 3, 2, 1, midGreen)
    @green_leaf_bitmaps[8].set_pixel(5, 3, khaki)
    @green_leaf_bitmaps[8].set_pixel(2, 4, midGreen)
    @green_leaf_bitmaps[8].set_pixel(3, 4, khaki)
    @green_leaf_bitmaps[8].set_pixel(4, 4, lightGreen)
    @green_leaf_bitmaps[8].set_pixel(5, 4, midGreen)
    @green_leaf_bitmaps[8].set_pixel(1, 5, midGreen)
    @green_leaf_bitmaps[8].set_pixel(2, 5, khaki)
    @green_leaf_bitmaps[8].fill_rect(3, 5, 2, 1, midGreen)
    @green_leaf_bitmaps[8].set_pixel(1, 6, darkGreen)
    @green_leaf_bitmaps[8].set_pixel(2, 6, midGreen)
    
    # 10th leaf bitmap
    @green_leaf_bitmaps[9] = Bitmap.new(8, 8)
    @green_leaf_bitmaps[9].fill_rect(6, 2, 2, 1, midGreen)
    @green_leaf_bitmaps[9].fill_rect(4, 3, 2, 1, midGreen)
    @green_leaf_bitmaps[9].set_pixel(6, 3, khaki)
    @green_leaf_bitmaps[9].set_pixel(3, 4, midGreen)
    @green_leaf_bitmaps[9].set_pixel(4, 4, khaki)
    @green_leaf_bitmaps[9].set_pixel(5, 4, lightGreen)
    @green_leaf_bitmaps[9].set_pixel(6, 4, mint)
    @green_leaf_bitmaps[9].set_pixel(1, 5, midGreen)
    @green_leaf_bitmaps[9].set_pixel(2, 5, khaki)
    @green_leaf_bitmaps[9].fill_rect(3, 5, 2, 1, mint)
    @green_leaf_bitmaps[9].set_pixel(5, 5, lightGreen)
    @green_leaf_bitmaps[9].set_pixel(2, 6, midGreen)
    @green_leaf_bitmaps[9].set_pixel(3, 6, khaki)
    @green_leaf_bitmaps[9].set_pixel(4, 6, lightGreen)
    
    # 11th leaf bitmap
    @green_leaf_bitmaps[10] = Bitmap.new(8, 8)
    @green_leaf_bitmaps[10].set_pixel(6, 2, midGreen)
    @green_leaf_bitmaps[10].set_pixel(7, 2, darkGreen)
    @green_leaf_bitmaps[10].fill_rect(4, 3, 2, 1, midGreen)
    @green_leaf_bitmaps[10].set_pixel(6, 3, khaki)
    @green_leaf_bitmaps[10].set_pixel(2, 4, darkGreen)
    @green_leaf_bitmaps[10].fill_rect(3, 4, 2, 1, khaki)
    @green_leaf_bitmaps[10].set_pixel(5, 4, lightGreen)
    @green_leaf_bitmaps[10].set_pixel(6, 4, khaki)
    @green_leaf_bitmaps[10].set_pixel(1, 5, midGreen)
    @green_leaf_bitmaps[10].set_pixel(2, 5, khaki)
    @green_leaf_bitmaps[10].set_pixel(3, 5, lightGreen)
    @green_leaf_bitmaps[10].set_pixel(4, 5, mint)
    @green_leaf_bitmaps[10].set_pixel(5, 5, midGreen)
    @green_leaf_bitmaps[10].set_pixel(2, 6, darkGreen)
    @green_leaf_bitmaps[10].fill_rect(3, 6, 2, 1, midGreen)
    
    
    
    # 12th leaf bitmap
    @green_leaf_bitmaps[11] = Bitmap.new(8, 8)
    @green_leaf_bitmaps[11].fill_rect(0, 3, 1, 2, darkGreen)
    @green_leaf_bitmaps[11].set_pixel(1, 4, midGreen)
    @green_leaf_bitmaps[11].set_pixel(2, 4, khaki)
    @green_leaf_bitmaps[11].set_pixel(3, 4, lightGreen)
    @green_leaf_bitmaps[11].set_pixel(4, 4, darkGreen)
    @green_leaf_bitmaps[11].set_pixel(7, 4, midGreen)
    @green_leaf_bitmaps[11].set_pixel(1, 5, darkGreen)
    @green_leaf_bitmaps[11].set_pixel(2, 5, midGreen)
    @green_leaf_bitmaps[11].set_pixel(3, 5, lightGreen)
    @green_leaf_bitmaps[11].set_pixel(4, 5, mint)
    @green_leaf_bitmaps[11].set_pixel(5, 5, lightGreen)
    @green_leaf_bitmaps[11].set_pixel(6, 5, khaki)
    @green_leaf_bitmaps[11].set_pixel(7, 5, midGreen)
    @green_leaf_bitmaps[11].fill_rect(2, 6, 2, 1, midGreen)
    @green_leaf_bitmaps[11].set_pixel(4, 6, lightGreen)
    @green_leaf_bitmaps[11].set_pixel(5, 6, khaki)
    @green_leaf_bitmaps[11].set_pixel(6, 6, midGreen)
    
    # 13th leaf bitmap
    @green_leaf_bitmaps[12] = Bitmap.new(8, 8)
    @green_leaf_bitmaps[12].set_pixel(1, 1, darkGreen)
    @green_leaf_bitmaps[12].fill_rect(1, 2, 2, 1, midGreen)
    @green_leaf_bitmaps[12].set_pixel(2, 3, midGreen)
    @green_leaf_bitmaps[12].set_pixel(3, 3, darkGreen)
    @green_leaf_bitmaps[12].set_pixel(4, 3, midGreen)
    @green_leaf_bitmaps[12].fill_rect(2, 4, 2, 1, midGreen)
    @green_leaf_bitmaps[12].set_pixel(4, 4, darkGreen)
    @green_leaf_bitmaps[12].set_pixel(5, 4, lightGreen)
    @green_leaf_bitmaps[12].set_pixel(3, 5, midGreen)
    @green_leaf_bitmaps[12].set_pixel(4, 5, darkGreen)
    @green_leaf_bitmaps[12].fill_rect(5, 5, 2, 1, khaki)
    @green_leaf_bitmaps[12].fill_rect(4, 6, 2, 1, midGreen)
    @green_leaf_bitmaps[12].set_pixel(6, 6, lightGreen)
    @green_leaf_bitmaps[12].set_pixel(6, 7, khaki)
    
    @rose_bitmaps = []
    brightRed = Color.new(255, 0, 0, 255)
    midRed = Color.new(179, 17, 17, 255)
    darkRed = Color.new(141, 9, 9, 255)
    
    # 1st rose petal bitmap
    @rose_bitmaps[0] = Bitmap.new(3, 3)
    @rose_bitmaps[0].fill_rect(1, 0, 2, 1, brightRed)
    @rose_bitmaps[0].fill_rect(0, 1, 1, 2, brightRed)
    @rose_bitmaps[0].fill_rect(1, 1, 2, 2, midRed)
    @rose_bitmaps[0].set_pixel(2, 2, darkRed)
    
    # 2nd rose petal bitmap
    @rose_bitmaps[1] = Bitmap.new(3, 3)
    @rose_bitmaps[1].set_pixel(0, 1, midRed)
    @rose_bitmaps[1].set_pixel(1, 1, brightRed)
    @rose_bitmaps[1].fill_rect(1, 2, 1, 2, midRed)
    
    @feather_bitmaps = []
    white = Color.new(255, 255, 255, 255)
    
    # 1st feather bitmap
    @feather_bitmaps[0] = Bitmap.new(3, 3)
    @feather_bitmaps[0].set_pixel(0, 2, white)
    @feather_bitmaps[0].set_pixel(1, 2, grey)
    @feather_bitmaps[0].set_pixel(2, 1, grey)
    
    # 2nd feather bitmap
    @feather_bitmaps[0] = Bitmap.new(3, 3)
    @feather_bitmaps[0].set_pixel(0, 0, white)
    @feather_bitmaps[0].set_pixel(0, 1, grey)
    @feather_bitmaps[0].set_pixel(1, 2, grey)
    
    # 3rd feather bitmap
    @feather_bitmaps[0] = Bitmap.new(3, 3)
    @feather_bitmaps[0].set_pixel(2, 0, white)
    @feather_bitmaps[0].set_pixel(1, 0, grey)
    @feather_bitmaps[0].set_pixel(0, 1, grey)
    
    # 4th feather bitmap
    @feather_bitmaps[0] = Bitmap.new(3, 3)
    @feather_bitmaps[0].set_pixel(2, 2, white)
    @feather_bitmaps[0].set_pixel(2, 1, grey)
    @feather_bitmaps[0].set_pixel(1, 0, grey)
    
    @blood_rain_bitmap = Bitmap.new(7, 56)
    for i in 0..6
    @blood_rain_bitmap.fill_rect(6-i, i*8, 1, 8, darkRed)
    end
    
    @sparkle_bitmaps = []
    
    lightBlue = Color.new(181, 244, 255, 255)
    midBlue = Color.new(126, 197, 235, 255)
    darkBlue = Color.new(77, 136, 225, 255)
    
    # 1st sparkle bitmap
    @sparkle_bitmaps[0] = Bitmap.new(7, 7)
    @sparkle_bitmaps[0].set_pixel(3, 3, darkBlue)
    
    # 2nd sparkle bitmap
    @sparkle_bitmaps[1] = Bitmap.new(7, 7)
    @sparkle_bitmaps[1].fill_rect(3, 2, 1, 3, darkBlue)
    @sparkle_bitmaps[1].fill_rect(2, 3, 3, 1, darkBlue)
    @sparkle_bitmaps[1].set_pixel(3, 3, midBlue)
    
    # 3rd sparkle bitmap
    @sparkle_bitmaps[2] = Bitmap.new(7, 7)
    @sparkle_bitmaps[2].set_pixel(1, 1, darkBlue)
    @sparkle_bitmaps[2].set_pixel(5, 1, darkBlue)
    @sparkle_bitmaps[2].set_pixel(2, 2, midBlue)
    @sparkle_bitmaps[2].set_pixel(4, 2, midBlue)
    @sparkle_bitmaps[2].set_pixel(3, 3, lightBlue)
    @sparkle_bitmaps[2].set_pixel(2, 4, midBlue)
    @sparkle_bitmaps[2].set_pixel(4, 4, midBlue)
    @sparkle_bitmaps[2].set_pixel(1, 5, darkBlue)
    @sparkle_bitmaps[2].set_pixel(5, 5, darkBlue)
    
    # 4th sparkle bitmap
    @sparkle_bitmaps[3] = Bitmap.new(7, 7)
    @sparkle_bitmaps[3].fill_rect(3, 1, 1, 5, darkBlue)
    @sparkle_bitmaps[3].fill_rect(1, 3, 5, 1, darkBlue)
    @sparkle_bitmaps[3].fill_rect(3, 2, 1, 3, midBlue)
    @sparkle_bitmaps[3].fill_rect(2, 3, 3, 1, midBlue)
    @sparkle_bitmaps[3].set_pixel(3, 3, lightBlue)
    
    # 5th sparkle bitmap
    @sparkle_bitmaps[4] = Bitmap.new(7, 7)
    @sparkle_bitmaps[4].fill_rect(2, 2, 3, 3, midBlue)
    @sparkle_bitmaps[4].fill_rect(3, 2, 1, 3, darkBlue)
    @sparkle_bitmaps[4].fill_rect(2, 3, 3, 1, darkBlue)
    @sparkle_bitmaps[4].set_pixel(3, 3, lightBlue)
    @sparkle_bitmaps[4].set_pixel(1, 1, darkBlue)
    @sparkle_bitmaps[4].set_pixel(5, 1, darkBlue)
    @sparkle_bitmaps[4].set_pixel(1, 5, darkBlue)
    @sparkle_bitmaps[4].set_pixel(5, 1, darkBlue)
    
    # 6th sparkle bitmap
    @sparkle_bitmaps[5] = Bitmap.new(7, 7)
    @sparkle_bitmaps[5].fill_rect(2, 1, 3, 5, darkBlue)
    @sparkle_bitmaps[5].fill_rect(1, 2, 5, 3, darkBlue)
    @sparkle_bitmaps[5].fill_rect(2, 2, 3, 3, midBlue)
    @sparkle_bitmaps[5].fill_rect(3, 1, 1, 5, midBlue)
    @sparkle_bitmaps[5].fill_rect(1, 3, 5, 1, midBlue)
    @sparkle_bitmaps[5].fill_rect(3, 2, 1, 3, lightBlue)
    @sparkle_bitmaps[5].fill_rect(2, 3, 3, 1, lightBlue)
    @sparkle_bitmaps[5].set_pixel(3, 3, white)
    
    # 7th sparkle bitmap
    @sparkle_bitmaps[6] = Bitmap.new(7, 7)
    @sparkle_bitmaps[6].fill_rect(2, 1, 3, 5, midBlue)
    @sparkle_bitmaps[6].fill_rect(1, 2, 5, 3, midBlue)
    @sparkle_bitmaps[6].fill_rect(3, 0, 1, 7, darkBlue)
    @sparkle_bitmaps[6].fill_rect(0, 3, 7, 1, darkBlue)
    @sparkle_bitmaps[6].fill_rect(2, 2, 3, 3, lightBlue)
    @sparkle_bitmaps[6].fill_rect(3, 2, 1, 3, midBlue)
    @sparkle_bitmaps[6].fill_rect(2, 3, 3, 1, midBlue)
    @sparkle_bitmaps[6].set_pixel(3, 3, white)
    
    @user_bitmaps = []
    update_user_defined
    end
    
    def update_user_defined
    for image in @user_bitmaps
    image.dispose
    end
    
    #user-defined bitmaps
    for name in $WEATHER_IMAGES
    @user_bitmaps.push(RPG::Cache.picture(name))
    end
    for sprite in @sprites
    sprite.bitmap = @user_bitmaps[rand(@user_bitmaps.size)]
    end
    end
    
    attr_reader :type
    attr_reader :max
    attr_reader :ox
    attr_reader :oy
    end
    end

     

     

     

     

    poi dice di creare un evento e mettere questo codice con il call script

     

    $game_screen.weather(0, 50, 0).

     

    e che al posto del primo 0 bisogna mettere un numero in base alle condizioni amtosferiche ovvero:

     

    1 - Pioggia verticale lenta
    2 - Pioggia obliqua veloce
    3 -  Neve
    4 - Grandine
    5 - Pioggia con tuoni
    6 - Foglie rosse lente
    7 - Foglie rosse che si spostano orizzontalmente
    8 - Foglie roose veloci
    9 - Foglie verdi che cadono
    10 - Petali rosa
    11 - Petali rossi
    12 - Plumi
    13 - Pioggia rossa (di sangue)
    14 - Luci blu che cadono
    16 - Scintille in volo

     

    il ftt è che nn so come mettere il call script!!! fonte presa da

    (http://www.makerando.it/forum/?showtopic=1526)

  4. scusate vi scoccerò ma

     

    Nell'evento, in alto, puoi aggiungere una pagina in cui inserire nuovi comandi/istruzioni

     

    la pagina in questo caso è quella dopo oppure una alternativa inutile?nn ho capito bene

  5. andando in giro per siti ho trovato questo script che dava errori e l'ho completato consiste nel saltare col char con il tasto z o spazio

     

    #==============================================================================
    #CODICE
    #==============================================================================
    # ■ Jump Script
    #------------------------------------------------------------------------------
    # Enables jumping around the map
    #==============================================================================
    
    #==============================================================================
    # ● Customisation
    #==============================================================================
    
    JumpID = 1 # The terrain ID of the tiles which can be jumped over
    MaxJump = 2 # The longest jump that can be made by the player
    
    #==============================================================================
    # ● Game_Player
    #==============================================================================
    
    class Game_Player < Game_Character
    
    def leap
    # finds the jumpable distance
    dist = jumpable_distance
    
    # finds the increases to x & y for the current direction
    xdir = (@direction == 6 ? 1 : @direction == 4 ? -1 : 0)
    ydir = (@direction == 2 ? 1 : @direction == 8 ? -1 : 0)
    
    route = RPG::MoveRoute.new
    route.list.clear
    route.list.push(RPG::MoveCommand.new(37))
    route.list.push(RPG::MoveCommand.new(14, [xdir * dist, ydir * dist]))
    route.list.push(RPG::MoveCommand.new(38))
    route.list.push(RPG::MoveCommand.new(0))
    route.repeat = false
    
    $game_player.force_move_route(route)
    end
    
    alias update_primary update
    def update
    update_primary
    
    leap if Input.trigger?(Input::A) && !moving?
    end
    
    def jumpable_distance(dir = @direction, max_dist = MaxJump, x = @x, y = @y)
    xdir = (dir == 6 ? 1 : dir == 4 ? -1 : 0)
    ydir = (dir == 2 ? 1 : dir == 8 ? -1 : 0)
    
    jumpable_tiles = []
    
    for i in 0..max_dist
    check_x = x + i * xdir
    check_y = y + i * ydir
    
    e = $game_map.events[$game_map.check_event(check_x, check_y)]
    if e
    if e.list[0].parameters[0] =~ "\Tall"
    break
    end
    if not e.through
    next
    end
    end
    
    if $game_map.passable?(check_x, check_y, dir, self) or
    $game_map.terrain_tag(check_x, check_y) == JumpID
    jumpable_tiles.push(i)
    end
    end
    
    jumpable_tiles.reverse.each do |i|
    check_x = x + i * xdir
    check_y = y + i * ydir
    
    return i if $game_map.passable?(check_x, check_y, dir, self)
    end
    
    return 0
    end
    
    end

  6. salve a tutto piacere di conoscevi :blink:

     

    sono nuovo di qui e mi sono registrato apposta per risolvermi un dilemma.....vorei far ripetere un evento una volta sola ho visto gia come si fa ma nn ho capito bene spero mi diato una mano grz in anticipo :blink:

×
×
  • Create New...