Jump to content
Rpg²S Forum

Sora-Master

Utenti
  • Posts

    215
  • Joined

  • Last visited

Posts posted by Sora-Master

  1. Descrizione: script permette di visualizzare una barra sotto agli hp/sp/exp nel menu
    Utilizzo: Incollare script sopra main

     

     

    # HP/SP/EXPƒQ?[ƒW•\ަƒXƒNƒŠƒvƒg Ver 1.00
    # ”z•zŒ³?EƒTƒ|?[ƒgURL
    # http://members.jcom.home.ne.jp/cogwheel/
    
    #==============================================================================
    # ?¡ Game_Actor
    #------------------------------------------------------------------------------
    # ?@ƒAƒNƒ^?[‚ðˆµ‚¤ƒNƒ‰ƒX‚Å‚·?B‚±‚̃Nƒ‰ƒX‚Í Game_Actors ƒNƒ‰ƒX ($game_actors)
    # ‚Ì“à•”‚ÅŽg—p‚³‚ê?AGame_Party ƒNƒ‰ƒX ($game_party) ‚©‚ç‚àŽQ?Æ‚³‚ê‚Ü‚·?B
    #==============================================================================
    
    class Game_Actor < Game_Battler
    	def now_exp
    		return @exp - @exp_list[@level]
    	end
    	def next_exp
    		return @exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0
    	end
    end
    
    #==============================================================================
    # ?¡ Window_Base
    #------------------------------------------------------------------------------
    # ?@ƒQ?[ƒ€’†‚Ì‚·‚ׂẴEƒBƒ“ƒhƒE‚̃X?[ƒp?[ƒNƒ‰ƒX‚Å‚·?B
    #==============================================================================
    
    class Window_Base < Window
    	#--------------------------------------------------------------------------
    	# ?œ HP ƒQ?[ƒW‚Ì•`‰æ
    	#--------------------------------------------------------------------------
    	# ƒIƒŠƒWƒiƒ‹‚ÌHP•`‰æ‚ð draw_actor_hp_original ‚Æ–¼‘O•Ï?X
    	alias :draw_actor_hp_original :draw_actor_hp
    	def draw_actor_hp(actor, x, y, width = 144)
    		# •Ï?”rate‚É Œ»?Ý‚ÌHP/MHP‚ð‘ã“ü
    		if actor.maxhp != 0
    			rate = actor.hp.to_f / actor.maxhp
    		else
    			rate = 0
    		end
    		# plus_x:X?À•W‚̈ʒu•â?³ rate_x:X?À•W‚̈ʒu•â?³(%) plus_y:Y?À•W‚̈ʒu•â?³
    		# plus_width:•?‚Ì•â?³ rate_width:•?‚Ì•â?³(%) height:?c•?
    		# align1:•`‰æƒ^ƒCƒv1 0:?¶‹l‚ß 1:’†‰›‘µ‚¦ 2:‰E‹l‚ß
    		# align2:•`‰æƒ^ƒCƒv2 0:?ã‹l‚ß 1:’†‰›‘µ‚¦ 2:‰º‹l‚ß
    		# align3:ƒQ?[ƒWƒ^ƒCƒv 0:?¶‹l‚ß 1:‰E‹l‚ß
    		plus_x = 0
    		rate_x = 0
    		plus_y = 25
    		plus_width = 0
    		rate_width = 100
    		height = 10
    		align1 = 1
    		align2 = 2
    		align3 = 0
    		# ƒOƒ‰ƒf?[ƒVƒ‡ƒ“?Ý’è grade1:‹óƒQ?[ƒW grade2:ŽÀƒQ?[ƒW
    		# (0:‰¡‚ɃOƒ‰ƒf?[ƒVƒ‡ƒ“ 1:?c‚ɃOƒ‰ƒf?[ƒVƒ‡ƒ“ 2:ŽÎ‚߂ɃOƒ‰ƒf?[ƒVƒ‡ƒ“(Œƒ?d)?j
    		grade1 = 1
    		grade2 = 0
    		# ?F?Ý’è?Bcolor1:ŠO˜g?Ccolor2:’†˜g
    		# color3:‹óƒQ?[ƒWƒ_?[ƒNƒJƒ‰?[?Ccolor4:‹óƒQ?[ƒWƒ‰ƒCƒgƒJƒ‰?[
    		# color5:ŽÀƒQ?[ƒWƒ_?[ƒNƒJƒ‰?[?Ccolor6:ŽÀƒQ?[ƒWƒ‰ƒCƒgƒJƒ‰?[
    		color1 = Color.new(0, 0, 0, 192)
    		color2 = Color.new(255, 255, 192, 192)
    		color3 = Color.new(0, 0, 0, 192)
    		color4 = Color.new(64, 0, 0, 192)
    		color5 = Color.new(80 - 24 * rate, 80 * rate, 14 * rate, 192)
    		color6 = Color.new(240 - 72 * rate, 240 * rate, 62 * rate, 192)
    		# •Ï?”sp‚É•`‰æ‚·‚éƒQ?[ƒW‚Ì•?‚ð‘ã“ü
    		if actor.maxhp != 0
    			hp = (width + plus_width) * actor.hp * rate_width / 100 / actor.maxhp
    		else
    			hp = 0
    		end
    		# ƒQ?[ƒW‚Ì•`‰æ
    		gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
    		width, plus_width + width * rate_width / 100,
    		height, hp, align1, align2, align3,
    		color1, color2, color3, color4, color5, color6, grade1, grade2)
    		# ƒIƒŠƒWƒiƒ‹‚ÌHP•`‰æ?ˆ—?‚ðŒÄ‚Ñ?o‚µ
    		draw_actor_hp_original(actor, x, y, width)
    	end
    	#--------------------------------------------------------------------------
    	# ?œ SP ƒQ?[ƒW‚Ì•`‰æ
    	#--------------------------------------------------------------------------
    	# ƒIƒŠƒWƒiƒ‹‚ÌSP•`‰æ‚ð draw_actor_sp_original ‚Æ–¼‘O•Ï?X
    	alias :draw_actor_sp_original :draw_actor_sp
    	def draw_actor_sp(actor, x, y, width = 144)
    		# •Ï?”rate‚É Œ»?Ý‚ÌSP/MSP‚ð‘ã“ü
    		if actor.maxsp != 0
    			rate = actor.sp.to_f / actor.maxsp
    		else
    			rate = 1
    		end
    		# plus_x:X?À•W‚̈ʒu•â?³ rate_x:X?À•W‚̈ʒu•â?³(%) plus_y:Y?À•W‚̈ʒu•â?³
    		# plus_width:•?‚Ì•â?³ rate_width:•?‚Ì•â?³(%) height:?c•?
    		# align1:•`‰æƒ^ƒCƒv1 0:?¶‹l‚ß 1:’†‰›‘µ‚¦ 2:‰E‹l‚ß
    		# align2:•`‰æƒ^ƒCƒv2 0:?ã‹l‚ß 1:’†‰›‘µ‚¦ 2:‰º‹l‚ß
    		# align3:ƒQ?[ƒWƒ^ƒCƒv 0:?¶‹l‚ß 1:‰E‹l‚ß
    		plus_x = 0
    		rate_x = 0
    		plus_y = 25
    		plus_width = 0
    		rate_width = 100
    		height = 10
    		align1 = 1
    		align2 = 2
    		align3 = 0
    		# ƒOƒ‰ƒf?[ƒVƒ‡ƒ“?Ý’è grade1:‹óƒQ?[ƒW grade2:ŽÀƒQ?[ƒW
    		# (0:‰¡‚ɃOƒ‰ƒf?[ƒVƒ‡ƒ“ 1:?c‚ɃOƒ‰ƒf?[ƒVƒ‡ƒ“ 2:ŽÎ‚߂ɃOƒ‰ƒf?[ƒVƒ‡ƒ“(Œƒ?d)?j
    		grade1 = 1
    		grade2 = 0
    		# ?F?Ý’è?Bcolor1:ŠO˜g?Ccolor2:’†˜g
    		# color3:‹óƒQ?[ƒWƒ_?[ƒNƒJƒ‰?[?Ccolor4:‹óƒQ?[ƒWƒ‰ƒCƒgƒJƒ‰?[
    		# color5:ŽÀƒQ?[ƒWƒ_?[ƒNƒJƒ‰?[?Ccolor6:ŽÀƒQ?[ƒWƒ‰ƒCƒgƒJƒ‰?[
    		color1 = Color.new(0, 0, 0, 192)
    		color2 = Color.new(255, 255, 192, 192)
    		color3 = Color.new(0, 0, 0, 192)
    		color4 = Color.new(0, 64, 0, 192)
    		color5 = Color.new(14 * rate, 80 - 24 * rate, 80 * rate, 192)
    		color6 = Color.new(62 * rate, 240 - 72 * rate, 240 * rate, 192)
    		# •Ï?”sp‚É•`‰æ‚·‚éƒQ?[ƒW‚Ì•?‚ð‘ã“ü
    		if actor.maxsp != 0
    			sp = (width + plus_width) * actor.sp * rate_width / 100 / actor.maxsp
    		else
    			sp = (width + plus_width) * rate_width / 100
    		end
    		# ƒQ?[ƒW‚Ì•`‰æ
    		gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
    		width, plus_width + width * rate_width / 100,
    		height, sp, align1, align2, align3,
    		color1, color2, color3, color4, color5, color6, grade1, grade2)
    		# ƒIƒŠƒWƒiƒ‹‚ÌSP•`‰æ?ˆ—?‚ðŒÄ‚Ñ?o‚µ
    		draw_actor_sp_original(actor, x, y, width)
    	end
    	#--------------------------------------------------------------------------
    	# ?œ EXP ƒQ?[ƒW‚Ì•`‰æ
    	#--------------------------------------------------------------------------
    	# ƒIƒŠƒWƒiƒ‹‚ÌEXP•`‰æ‚ð draw_actor_sp_original ‚Æ–¼‘O•Ï?X
    	alias :draw_actor_exp_original :draw_actor_exp
    	def draw_actor_exp(actor, x, y, width = 204)
    		# •Ï?”rate‚É Œ»?Ý‚Ìexp/nextexp‚ð‘ã“ü
    		if actor.next_exp != 0
    			rate = actor.now_exp.to_f / actor.next_exp
    		else
    			rate = 1
    		end
    		# plus_x:X?À•W‚̈ʒu•â?³ rate_x:X?À•W‚̈ʒu•â?³(%) plus_y:Y?À•W‚̈ʒu•â?³
    		# plus_width:•?‚Ì•â?³ rate_width:•?‚Ì•â?³(%) height:?c•?
    		# align1:•`‰æƒ^ƒCƒv1 0:?¶‹l‚ß 1:’†‰›‘µ‚¦ 2:‰E‹l‚ß
    		# align2:•`‰æƒ^ƒCƒv2 0:?ã‹l‚ß 1:’†‰›‘µ‚¦ 2:‰º‹l‚ß
    		# align3:ƒQ?[ƒWƒ^ƒCƒv 0:?¶‹l‚ß 1:‰E‹l‚ß
    		plus_x = 0
    		rate_x = 0
    		plus_y = 25
    		plus_width = 0
    		rate_width = 100
    		height = 10
    		align1 = 1
    		align2 = 2
    		align3 = 0
    		# ƒOƒ‰ƒf?[ƒVƒ‡ƒ“?Ý’è grade1:‹óƒQ?[ƒW grade2:ŽÀƒQ?[ƒW
    		# (0:‰¡‚ɃOƒ‰ƒf?[ƒVƒ‡ƒ“ 1:?c‚ɃOƒ‰ƒf?[ƒVƒ‡ƒ“ 2:ŽÎ‚߂ɃOƒ‰ƒf?[ƒVƒ‡ƒ“(Œƒ?d)?j
    		grade1 = 1
    		grade2 = 0
    		# ?F?Ý’è?Bcolor1:ŠO˜g?Ccolor2:’†˜g
    		# color3:‹óƒQ?[ƒWƒ_?[ƒNƒJƒ‰?[?Ccolor4:‹óƒQ?[ƒWƒ‰ƒCƒgƒJƒ‰?[
    		# color5:ŽÀƒQ?[ƒWƒ_?[ƒNƒJƒ‰?[?Ccolor6:ŽÀƒQ?[ƒWƒ‰ƒCƒgƒJƒ‰?[
    		color1 = Color.new(0, 0, 0, 192)
    		color2 = Color.new(255, 255, 192, 192)
    		color3 = Color.new(0, 0, 0, 192)
    		color4 = Color.new(64, 0, 0, 192)
    		color5 = Color.new(80 * rate, 80 - 80 * rate ** 2, 80 - 80 * rate, 192)
    		color6 = Color.new(240 * rate, 240 - 240 * rate ** 2, 240 - 240 * rate, 192)
    		# •Ï?”exp‚É•`‰æ‚·‚éƒQ?[ƒW‚Ì•?‚ð‘ã“ü
    		if actor.next_exp != 0
    			exp = (width + plus_width) * actor.now_exp * rate_width /
    			100 / actor.next_exp
    		else
    			exp = (width + plus_width) * rate_width / 100
    		end
    		# ƒQ?[ƒW‚Ì•`‰æ
    		gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
    		width, plus_width + width * rate_width / 100,
    		height, exp, align1, align2, align3,
    		color1, color2, color3, color4, color5, color6, grade1, grade2)
    		# ƒIƒŠƒWƒiƒ‹‚ÌEXP•`‰æ?ˆ—?‚ðŒÄ‚Ñ?o‚µ
    		draw_actor_exp_original(actor, x, y)
    	end
    	#--------------------------------------------------------------------------
    	# ?œ ƒQ?[ƒW‚Ì•`‰æ
    	#--------------------------------------------------------------------------
    	def gauge_rect(x, y, rect_width, width, height, gauge, align1, align2, align3,
    		color1, color2, color3, color4, color5, color6, grade1, grade2)
    		case align1
    		when 1
    			x += (rect_width - width) / 2
    		when 2
    			x += rect_width - width
    		end
    		case align2
    		when 1
    			y -= height / 2
    		when 2
    			y -= height
    		end
    		# ˜g•`‰æ
    		self.contents.fill_rect(x, y, width, height, color1)
    		self.contents.fill_rect(x + 1, y + 1, width - 2, height - 2, color2)
    		if align3 == 0
    			if grade1 == 2
    				grade1 = 3
    			end
    			if grade2 == 2
    				grade2 = 3
    			end
    		end
    		if (align3 == 1 and grade1 == 0) or grade1 > 0
    			color = color3
    			color3 = color4
    			color4 = color
    		end
    		if (align3 == 1 and grade2 == 0) or grade2 > 0
    			color = color5
    			color5 = color6
    			color6 = color
    		end
    		# ‹óƒQ?[ƒW‚Ì•`‰æ
    		self.contents.gradation_rect(x + 2, y + 2, width - 4, height - 4,
    		color3, color4, grade1)
    		if align3 == 1
    			x += width - gauge
    		end
    		# ŽÀƒQ?[ƒW‚Ì•`‰æ
    		self.contents.gradation_rect(x + 2, y + 2, gauge - 4, height - 4,
    		color5, color6, grade2)
    	end
    end
    
    #------------------------------------------------------------------------------
    # ?@BitmapƒNƒ‰ƒX‚É?V‚½‚È‹@”\‚ð’ljÁ‚µ‚Ü‚·?B
    #==============================================================================
    
    class Bitmap
    	#--------------------------------------------------------------------------
    	# ?œ ‹éŒ`‚ðƒOƒ‰ƒf?[ƒVƒ‡ƒ“•\ަ
    	# color1 : ƒXƒ^?[ƒgƒJƒ‰?[
    	# color2 : ƒGƒ“ƒhƒJƒ‰?[
    	# align : 0:‰¡‚ɃOƒ‰ƒf?[ƒVƒ‡ƒ“
    	# 1:?c‚ɃOƒ‰ƒf?[ƒVƒ‡ƒ“
    	# 2:ŽÎ‚߂ɃOƒ‰ƒf?[ƒVƒ‡ƒ“?iŒƒ?d‚ɂ‚«’?ˆÓ?j
    	#--------------------------------------------------------------------------
    	def gradation_rect(x, y, width, height, color1, color2, align = 0)
    		if align == 0
    			for i in x...x + width
    				red = color1.red + (color2.red - color1.red) * (i - x) / (width - 1)
    				green = color1.green +
    				(color2.green - color1.green) * (i - x) / (width - 1)
    				blue = color1.blue +
    				(color2.blue - color1.blue) * (i - x) / (width - 1)
    				alpha = color1.alpha +
    				(color2.alpha - color1.alpha) * (i - x) / (width - 1)
    				color = Color.new(red, green, blue, alpha)
    				fill_rect(i, y, 1, height, color)
    			end
    		elsif align == 1
    			for i in y...y + height
    				red = color1.red +
    				(color2.red - color1.red) * (i - y) / (height - 1)
    				green = color1.green +
    				(color2.green - color1.green) * (i - y) / (height - 1)
    				blue = color1.blue +
    				(color2.blue - color1.blue) * (i - y) / (height - 1)
    				alpha = color1.alpha +
    				(color2.alpha - color1.alpha) * (i - y) / (height - 1)
    				color = Color.new(red, green, blue, alpha)
    				fill_rect(x, i, width, 1, color)
    			end
    		elsif align == 2
    			for i in x...x + width
    				for j in y...y + height
    					red = color1.red + (color2.red - color1.red) *
    					((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
    					green = color1.green + (color2.green - color1.green) *
    					((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
    					blue = color1.blue + (color2.blue - color1.blue) *
    					((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
    					alpha = color1.alpha + (color2.alpha - color1.alpha) *
    					((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
    					color = Color.new(red, green, blue, alpha)
    					set_pixel(i, j, color)
    				end
    			end
    		elsif align == 3
    			for i in x...x + width
    				for j in y...y + height
    					red = color1.red + (color2.red - color1.red) *
    					((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
    					green = color1.green + (color2.green - color1.green) *
    					((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
    					blue = color1.blue + (color2.blue - color1.blue) *
    					((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
    					alpha = color1.alpha + (color2.alpha - color1.alpha) *
    					((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
    					color = Color.new(red, green, blue, alpha)
    					set_pixel(i, j, color)
    				end
    			end
    		end
    	end
    end
    
    #==============================================================================
    # ?¡ Spriteƒ‚ƒWƒ…?[ƒ‹
    #------------------------------------------------------------------------------
    # ?@ƒAƒjƒ??[ƒVƒ‡ƒ“‚ÌŠÇ—?‚ð?s‚¤ƒ‚ƒWƒ…?[ƒ‹‚Å‚·?B
    #==============================================================================
    
    module RPG
    	class Sprite < ::Sprite
    		def damage(value, critical)
    			dispose_damage
    			if value.is_a?(Numeric)
    				damage_string = value.abs.to_s
    			else
    				damage_string = value.to_s
    			end
    			bitmap = Bitmap.new(160, 48)
    			bitmap.font.name = "Arial Black"
    			bitmap.font.size = 32
    			bitmap.font.color.set(0, 0, 0)
    			bitmap.draw_text(-1, 12-1, 160, 36, damage_string, 1)
    			bitmap.draw_text(+1, 12-1, 160, 36, damage_string, 1)
    			bitmap.draw_text(-1, 12+1, 160, 36, damage_string, 1)
    			bitmap.draw_text(+1, 12+1, 160, 36, damage_string, 1)
    			if value.is_a?(Numeric) and value < 0
    				bitmap.font.color.set(176, 255, 144)
    			else
    				bitmap.font.color.set(255, 255, 255)
    			end
    			bitmap.draw_text(0, 12, 160, 36, damage_string, 1)
    			if critical
    				bitmap.font.size = 20
    				bitmap.font.color.set(0, 0, 0)
    				bitmap.draw_text(-1, -1, 160, 20, "CRITICAL", 1)
    				bitmap.draw_text(+1, -1, 160, 20, "CRITICAL", 1)
    				bitmap.draw_text(-1, +1, 160, 20, "CRITICAL", 1)
    				bitmap.draw_text(+1, +1, 160, 20, "CRITICAL", 1)
    				bitmap.font.color.set(255, 255, 255)
    				bitmap.draw_text(0, 0, 160, 20, "CRITICAL", 1)
    			end
    			@_damage_sprite = ::Sprite.new
    			@_damage_sprite.bitmap = bitmap
    			@_damage_sprite.ox = 80 + self.viewport.ox
    			@_damage_sprite.oy = 20 + self.viewport.oy
    			@_damage_sprite.x = self.x + self.viewport.rect.x
    			@_damage_sprite.y = self.y - self.oy / 2 + self.viewport.rect.y
    			@_damage_sprite.z = 3000
    			@_damage_duration = 40
    		end
    		def animation(animation, hit)
    			dispose_animation
    			@_animation = animation
    			return if @_animation == nil
    			@_animation_hit = hit
    			@_animation_duration = @_animation.frame_max
    			animation_name = @_animation.animation_name
    			animation_hue = @_animation.animation_hue
    			bitmap = RPG::Cache.animation(animation_name, animation_hue)
    			if @@_reference_count.include?(bitmap)
    				@@_reference_count[bitmap] += 1
    			else
    				@@_reference_count[bitmap] = 1
    			end
    			@_animation_sprites = []
    			if @_animation.position != 3 or not @@_animations.include?(animation)
    				for i in 0..15
    					sprite = ::Sprite.new
    					sprite.bitmap = bitmap
    					sprite.visible = false
    					@_animation_sprites.push(sprite)
    				end
    				unless @@_animations.include?(animation)
    					@@_animations.push(animation)
    				end
    			end
    			update_animation
    		end
    		def loop_animation(animation)
    			return if animation == @_loop_animation
    			dispose_loop_animation
    			@_loop_animation = animation
    			return if @_loop_animation == nil
    			@_loop_animation_index = 0
    			animation_name = @_loop_animation.animation_name
    			animation_hue = @_loop_animation.animation_hue
    			bitmap = RPG::Cache.animation(animation_name, animation_hue)
    			if @@_reference_count.include?(bitmap)
    				@@_reference_count[bitmap] += 1
    			else
    				@@_reference_count[bitmap] = 1
    			end
    			@_loop_animation_sprites = []
    			for i in 0..15
    				sprite = ::Sprite.new
    				sprite.bitmap = bitmap
    				sprite.visible = false
    				@_loop_animation_sprites.push(sprite)
    			end
    			update_loop_animation
    		end
    		def animation_set_sprites(sprites, cell_data, position)
    			for i in 0..15
    				sprite = sprites[i]
    				pattern = cell_data[i, 0]
    				if sprite == nil or pattern == nil or pattern == -1
    					sprite.visible = false if sprite != nil
    					next
    				end
    				sprite.visible = true
    				sprite.src_rect.set(pattern % 5 * 192, pattern / 5 * 192, 192, 192)
    				if position == 3
    					if self.viewport != nil
    						sprite.x = self.viewport.rect.width / 2
    						sprite.y = self.viewport.rect.height - 160
    					else
    						sprite.x = 320
    						sprite.y = 240
    					end
    				else
    					sprite.x = self.x + self.viewport.rect.x -
    					self.ox + self.src_rect.width / 2
    					sprite.y = self.y + self.viewport.rect.y -
    					self.oy + self.src_rect.height / 2
    					sprite.y -= self.src_rect.height / 4 if position == 0
    					sprite.y += self.src_rect.height / 4 if position == 2
    				end
    				sprite.x += cell_data[i, 1]
    				sprite.y += cell_data[i, 2]
    				sprite.z = 2000
    				sprite.ox = 96
    				sprite.oy = 96
    				sprite.zoom_x = cell_data[i, 3] / 100.0
    				sprite.zoom_y = cell_data[i, 3] / 100.0
    				sprite.angle = cell_data[i, 4]
    				sprite.mirror = (cell_data[i, 5] == 1)
    				sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
    				sprite.blend_type = cell_data[i, 7]
    			end
    		end
    	end
    end
    

     

     

  2. io ho diversi tipi di battlers ma nessuno funge (io uso lo script minkoff x il bs laterale) o si vede una figura e mezzo in più o non si anima per nnt mi aiutate? ecco alcuni:

     

    post-1166-1205234536_thumb.png post-1166-1205234579_thumb.png

     

    poi ho dei battler di naruto ma sono un formato diverso... se qualke anima buona può dirmi come aggiustarli .

    grazie

  3. nn so se esiste già uno script del genere cmq questo è un menù ad anello credo ke sia stato fatto da MakirouAru
     

     

     

    #==============================================================================
    # ¡ Window_RingMenu
    #==============================================================================
    #==============================================================================
    # Edited by MakirouAru
    #==============================================================================
    class Window_RingMenu < Window_Base
    	#--------------------------------------------------------------------------
    	# › ƒNƒ‰ƒX’è”
    	#--------------------------------------------------------------------------
    	STARTUP_FRAMES = 20 # ‰ŠúƒAƒjƒ[ƒVƒ‡ƒ“‚̃tƒŒ[ƒ€”
    	MOVING_FRAMES = 5 # ƒŠƒ“ƒO‚ð‰ñ‚µ‚½Žž‚̃tƒŒ[ƒ€”
    	RING_R = 64 # ƒŠƒ“ƒO‚Ì”¼Œa
    	ICON_ITEM = RPG::Cache.icon("034-Item03") # uƒAƒCƒeƒ€vƒƒjƒ…[‚̃AƒCƒRƒ“
    	ICON_SKILL = RPG::Cache.icon("044-Skill01") # uƒXƒLƒ‹vƒƒjƒ…[‚̃AƒCƒRƒ“
    	ICON_EQUIP = RPG::Cache.icon("001-Weapon01") # u‘•”õvƒƒjƒ…[‚̃AƒCƒRƒ“
    	ICON_STATUS = RPG::Cache.icon("050-Skill07") # uƒXƒe[ƒ^ƒXvƒƒjƒ…[‚̃AƒCƒRƒ“
    	ICON_SAVE = RPG::Cache.icon("038-Item07") # uƒZ[ƒuvƒƒjƒ…[‚̃AƒCƒRƒ“
    	ICON_EXIT = RPG::Cache.icon("046-Skill03") # uI—¹vƒƒjƒ…[‚̃AƒCƒRƒ“
    	ICON_DISABLE= RPG::Cache.icon("") # Žg—p‹ÖŽ~€–Ú‚É•t‚­ƒAƒCƒRƒ“
    	SE_STARTUP = "056-Right02" # ƒƒjƒ…[‚ðŠJ‚¢‚½‚Æ‚«‚ɖ‚炷SE
    	MODE_START = 1 # ƒXƒ^[ƒgƒAƒbƒvƒAƒjƒ[ƒVƒ‡ƒ“
    	MODE_WAIT = 2 # ‘Ò‹@
    	MODE_MOVER = 3 # ŽžŒv‰ñ‚è‰ñ“]ƒAƒjƒ[ƒVƒ‡ƒ“
    	MODE_MOVEL = 4 # ”½ŽžŒv‰ñ‚è‰ñ“]ƒAƒjƒ[ƒVƒ‡ƒ“
    	#--------------------------------------------------------------------------
    	# › ƒAƒNƒZƒT
    	#--------------------------------------------------------------------------
    	attr_accessor :index
    	#--------------------------------------------------------------------------
    	# œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
    	#--------------------------------------------------------------------------
    	def initialize( center_x, center_y )
    		super(0, 0, 640, 480)
    		self.contents = Bitmap.new(width-32, height-32)
    		self.contents.font.name = "Arial"
    		self.opacity = 0
    		self.back_opacity = 0
    		s1 = "Items"
    		s2 = "Skills"
    		s3 = "Equip"
    		s4 = "Stats"
    		s5 = "Save"
    		s6 = "Quit"
    		@commands = [ s1, s2, s3, s4, s5, s6 ]
    		@item_max = 6
    		@index = 0
    		@items = [ ICON_ITEM, ICON_SKILL, ICON_EQUIP, ICON_STATUS, ICON_SAVE, ICON_EXIT ]
    		@disabled = [ false, false, false, false, false, false ]
    		@cx = center_x - 16
    		@cy = center_y - 16
    		setup_move_start
    		refresh
    	end
    	#--------------------------------------------------------------------------
    	# œ ƒtƒŒ[ƒ€XV
    	#--------------------------------------------------------------------------
    	def update
    		super
    		refresh
    	end
    	#--------------------------------------------------------------------------
    	# œ ‰æ–ÊÄ•‰æ
    	#--------------------------------------------------------------------------
    	def refresh
    		self.contents.clear
    		# ƒAƒCƒRƒ“‚ð•‰æ
    		case @mode
    		when MODE_START
    			refresh_start
    		when MODE_WAIT
    			refresh_wait
    		when MODE_MOVER
    			refresh_move(1)
    		when MODE_MOVEL
    			refresh_move(0)
    		end
    		# ƒAƒNƒeƒBƒu‚ȃRƒ}ƒ“ƒh–¼•\ަ
    		rect = Rect.new(@cx - 272, @cy + 24, self.contents.width-32, 32)
    		self.contents.draw_text(rect, @commands[@index],1)
    	end
    	#--------------------------------------------------------------------------
    	# › ‰æ–ÊÄ•‰æ(‰Šú‰»Žž)
    	#--------------------------------------------------------------------------
    	def refresh_start
    		d1 = 2.0 * Math::PI / @item_max
    		d2 = 1.0 * Math::PI / STARTUP_FRAMES
    		r = RING_R - 1.0 * RING_R * @steps / STARTUP_FRAMES
    		for i in 0...@item_max
    			j = i - @index
    			d = d1 * j + d2 * @steps
    			x = @cx + ( r * Math.sin( d ) ).to_i
    			y = @cy - ( r * Math.cos( d ) ).to_i
    			draw_item(x, y, i)
    		end
    		@steps -= 1
    		if @steps < 1
    			@mode = MODE_WAIT
    		end
    	end
    	#--------------------------------------------------------------------------
    	# › ‰æ–ÊÄ•‰æ(‘Ò‹@Žž)
    	#--------------------------------------------------------------------------
    	def refresh_wait
    		d = 2.0 * Math::PI / @item_max
    		for i in 0...@item_max
    			j = i - @index
    			x = @cx + ( RING_R * Math.sin( d * j ) ).to_i
    			y = @cy - ( RING_R * Math.cos( d * j ) ).to_i
    			draw_item(x, y, i)
    		end
    	end
    	#--------------------------------------------------------------------------
    	# › ‰æ–ÊÄ•‰æ(‰ñ“]Žž)
    	# mode : 0=”½ŽžŒv‰ñ‚è 1=ŽžŒv‰ñ‚è
    	#--------------------------------------------------------------------------
    	def refresh_move( mode )
    		d1 = 2.0 * Math::PI / @item_max
    		d2 = d1 / MOVING_FRAMES
    		d2 *= -1 if mode != 0
    		for i in 0...@item_max
    			j = i - @index
    			d = d1 * j + d2 * @steps
    			x = @cx + ( RING_R * Math.sin( d ) ).to_i
    			y = @cy - ( RING_R * Math.cos( d ) ).to_i
    			draw_item(x, y, i)
    		end
    		@steps -= 1
    		if @steps < 1
    			@mode = MODE_WAIT
    		end
    	end
    	#--------------------------------------------------------------------------
    	# œ €–Ú‚Ì•‰æ
    	# x :
    	# y :
    	# i : €–Ú”Ô†
    	#--------------------------------------------------------------------------
    	def draw_item(x, y, i)
    		#p "x=" + x.to_s + " y=" + y.to_s + " i=" + @items[i].to_s
    		rect = Rect.new(0, 0, @items[i].width, @items[i].height)
    		if @index == i
    			self.contents.blt( x, y, @items[i], rect )
    			if @disabled[@index]
    				self.contents.blt( x, y, ICON_DISABLE, rect )
    			end
    		else
    			self.contents.blt( x, y, @items[i], rect, 128 )
    			if @disabled[@index]
    				self.contents.blt( x, y, ICON_DISABLE, rect, 128 )
    			end
    		end
    	end
    	#--------------------------------------------------------------------------
    	# œ €–ڂ𖳌ø‚É‚·‚é
    	# index : €–Ú”Ô†
    	#--------------------------------------------------------------------------
    	def disable_item(index)
    		@disabled[index] = true
    	end
    	#--------------------------------------------------------------------------
    	# › ‰Šú‰»ƒAƒjƒ[ƒVƒ‡ƒ“‚Ì€”õ
    	#--------------------------------------------------------------------------
    	def setup_move_start
    		@mode = MODE_START
    		@steps = STARTUP_FRAMES
    		if SE_STARTUP != nil and SE_STARTUP != ""
    			Audio.se_play("Audio/SE/" + SE_STARTUP, 80, 100)
    		end
    	end
    	#--------------------------------------------------------------------------
    	# › ‰ñ“]ƒAƒjƒ[ƒVƒ‡ƒ“‚Ì€”õ
    	#--------------------------------------------------------------------------
    	def setup_move_move(mode)
    		if mode == MODE_MOVER
    			@index -= 1
    			@index = @items.size - 1 if @index < 0
    		elsif mode == MODE_MOVEL
    			@index += 1
    			@index = 0 if @index >= @items.size
    		else
    			return
    		end
    		@mode = mode
    		@steps = MOVING_FRAMES
    	end
    	#--------------------------------------------------------------------------
    	# › ƒAƒjƒ[ƒVƒ‡ƒ“’†‚©‚Ç‚¤‚©
    	#--------------------------------------------------------------------------
    	def animation?
    		return @mode != MODE_WAIT
    	end
    end
    #==============================================================================
    # ¡ Window_MenuStatus
    #------------------------------------------------------------------------------
    # @ƒƒjƒ…[‰æ–ʂŃp[ƒeƒBƒƒ“ƒo[‚̃Xƒe[ƒ^ƒX‚ð•\ަ‚·‚éƒEƒBƒ“ƒhƒE‚Å‚·B
    #==============================================================================
    
    class Window_RingMenuStatus < Window_Selectable
    	#--------------------------------------------------------------------------
    	# œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
    	#--------------------------------------------------------------------------
    	def initialize
    		super(204, 64, 232, 352)
    		self.contents = Bitmap.new(width - 32, height - 32)
    		refresh
    		self.active = false
    		self.index = -1
    	end
    	#--------------------------------------------------------------------------
    	# œ ƒŠƒtƒŒƒbƒVƒ…
    	#--------------------------------------------------------------------------
    	def refresh
    		self.contents.clear
    		self.contents.font.name = "Arial"
    		@item_max = $game_party.actors.size
    		for i in 0...$game_party.actors.size
    			x = 80
    			y = 80 * i
    			actor = $game_party.actors[i]
    			draw_actor_graphic(actor, x - 40, y + 80)
    			draw_actor_name(actor, x, y + 24)
    		end
    	end
    	#--------------------------------------------------------------------------
    	# œ ƒJ[ƒ\ƒ‹‚Ì‹éŒXV
    	#--------------------------------------------------------------------------
    	def update_cursor_rect
    		if @index < 0
    			self.cursor_rect.empty
    		else
    			self.cursor_rect.set(0, @index * 80, self.width - 32, 80)
    		end
    	end
    end
    #==============================================================================
    # #¡ Scene_RingMenu
    # ¡ Scene_Menu
    #------------------------------------------------------------------------------
    # @ƒƒjƒ…[‰æ–ʂ̈—‚ðs‚¤ƒNƒ‰ƒX‚Å‚·B
    #==============================================================================
    
    #class Scene_RingMenu
    class Scene_Menu
    	#--------------------------------------------------------------------------
    	# œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
    	# menu_index : ƒRƒ}ƒ“ƒh‚̃J[ƒ\ƒ‹‰ŠúˆÊ’u
    	#--------------------------------------------------------------------------
    	def initialize(menu_index = 0)
    		@menu_index = menu_index
    	end
    	#--------------------------------------------------------------------------
    	# œ ƒƒCƒ“ˆ—
    	#--------------------------------------------------------------------------
    	def main
    		# ƒXƒvƒ‰ƒCƒgƒZƒbƒg‚ðì¬
    		@spriteset = Spriteset_Map.new
    		# ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚ðì¬
    		px = $game_player.screen_x - 15
    		py = $game_player.screen_y - 24
    		@command_window = Window_RingMenu.new(px,py)
    		@command_window.index = @menu_index
    		# ƒp[ƒeƒBl”‚ª 0 l‚Ìê‡
    		if $game_party.actors.size == 0
    			# ƒAƒCƒeƒ€AƒXƒLƒ‹A‘•”õAƒXƒe[ƒ^ƒX‚𖳌ø‰»
    			@command_window.disable_item(0)
    			@command_window.disable_item(1)
    			@command_window.disable_item(2)
    			@command_window.disable_item(3)
    		end
    		@command_window.z = 100
    		# ƒZ[ƒu‹ÖŽ~‚Ìê‡
    		if $game_system.save_disabled
    			# ƒZ[ƒu‚𖳌ø‚É‚·‚é
    			@command_window.disable_item(4)
    		end
    		# ƒXƒe[ƒ^ƒXƒEƒBƒ“ƒhƒE‚ðì¬
    		@status_window = Window_RingMenuStatus.new
    		@status_window.x = 160
    		@status_window.y = 0
    		@status_window.z = 200
    		@status_window.visible = false
    		# ƒgƒ‰ƒ“ƒWƒVƒ‡ƒ“ŽÀs
    		Graphics.transition
    		# ƒƒCƒ“ƒ‹[ƒv
    		loop do
    			# ƒQ[ƒ€‰æ–Ê‚ðXV
    			Graphics.update
    			# “ü—Íî•ñ‚ðXV
    			Input.update
    			# ƒtƒŒ[ƒ€XV
    			update
    			# ‰æ–Ê‚ªØ‚è‘Ö‚í‚Á‚½‚烋[ƒv‚ð’†’f
    			if $scene != self
    				break
    			end
    		end
    		# ƒgƒ‰ƒ“ƒWƒVƒ‡ƒ“€”õ
    		Graphics.freeze
    		# ƒXƒvƒ‰ƒCƒgƒZƒbƒg‚ð‰ð•ú
    		@spriteset.dispose
    		# ƒEƒBƒ“ƒhƒE‚ð‰ð•ú
    		@command_window.dispose
    		@status_window.dispose
    	end
    	#--------------------------------------------------------------------------
    	# œ ƒtƒŒ[ƒ€XV
    	#--------------------------------------------------------------------------
    	def update
    		# ƒEƒBƒ“ƒhƒE‚ðXV
    		@command_window.update
    		@status_window.update
    		# ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚ªƒAƒNƒeƒBƒu‚Ìê‡: update_command ‚ðŒÄ‚Ô
    		if @command_window.active
    			update_command
    			return
    		end
    		# ƒXƒe[ƒ^ƒXƒEƒBƒ“ƒhƒE‚ªƒAƒNƒeƒBƒu‚Ìê‡: update_status ‚ðŒÄ‚Ô
    		if @status_window.active
    			update_status
    			return
    		end
    	end
    	#--------------------------------------------------------------------------
    	# œ ƒtƒŒ[ƒ€XV (ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚ªƒAƒNƒeƒBƒu‚Ìê‡)
    	#--------------------------------------------------------------------------
    	def update_command
    		# B ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽê‡
    		if Input.trigger?(Input::B)
    			# ƒLƒƒƒ“ƒZƒ‹ SE ‚ð‰‰‘t
    			$game_system.se_play($data_system.cancel_se)
    			# ƒ}ƒbƒv‰æ–Ê‚ÉØ‚è‘Ö‚¦
    			$scene = Scene_Map.new
    			return
    		end
    		# C ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽê‡
    		if Input.trigger?(Input::C)
    			# ƒp[ƒeƒBl”‚ª 0 l‚ÅAƒZ[ƒuAƒQ[ƒ€I—¹ˆÈŠO‚̃Rƒ}ƒ“ƒh‚Ìê‡
    			if $game_party.actors.size == 0 and @command_window.index < 4
    				# ƒuƒU[ SE ‚ð‰‰‘t
    				$game_system.se_play($data_system.buzzer_se)
    				return
    			end
    			# ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚̃J[ƒ\ƒ‹ˆÊ’u‚Å•ªŠò
    			case @command_window.index
    			when 0 # ƒAƒCƒeƒ€
    				# Œˆ’è SE ‚ð‰‰‘t
    				$game_system.se_play($data_system.decision_se)
    				# ƒAƒCƒeƒ€‰æ–Ê‚ÉØ‚è‘Ö‚¦
    				$scene = Scene_Item.new
    			when 1 # ƒXƒLƒ‹
    				# Œˆ’è SE ‚ð‰‰‘t
    				$game_system.se_play($data_system.decision_se)
    				# ƒXƒe[ƒ^ƒXƒEƒBƒ“ƒhƒE‚ðƒAƒNƒeƒBƒu‚É‚·‚é
    				@command_window.active = false
    				@status_window.active = true
    				@status_window.visible = true
    				@status_window.index = 0
    			when 2 # ‘•”õ
    				# Œˆ’è SE ‚ð‰‰‘t
    				$game_system.se_play($data_system.decision_se)
    				# ƒXƒe[ƒ^ƒXƒEƒBƒ“ƒhƒE‚ðƒAƒNƒeƒBƒu‚É‚·‚é
    				@command_window.active = false
    				@status_window.active = true
    				@status_window.visible = true
    				@status_window.index = 0
    			when 3 # ƒXƒe[ƒ^ƒX
    				# Œˆ’è SE ‚ð‰‰‘t
    				$game_system.se_play($data_system.decision_se)
    				# ƒXƒe[ƒ^ƒXƒEƒBƒ“ƒhƒE‚ðƒAƒNƒeƒBƒu‚É‚·‚é
    				@command_window.active = false
    				@status_window.active = true
    				@status_window.visible = true
    				@status_window.index = 0
    			when 4 # ƒZ[ƒu
    				# ƒZ[ƒu‹ÖŽ~‚Ìê‡
    				if $game_system.save_disabled
    					# ƒuƒU[ SE ‚ð‰‰‘t
    					$game_system.se_play($data_system.buzzer_se)
    					return
    				end
    				# Œˆ’è SE ‚ð‰‰‘t
    				$game_system.se_play($data_system.decision_se)
    				# ƒZ[ƒu‰æ–Ê‚ÉØ‚è‘Ö‚¦
    				$scene = Scene_Save.new
    			when 5 # ƒQ[ƒ€I—¹
    				# Œˆ’è SE ‚ð‰‰‘t
    				$game_system.se_play($data_system.decision_se)
    				# ƒQ[ƒ€I—¹‰æ–Ê‚ÉØ‚è‘Ö‚¦
    				$scene = Scene_End.new
    			end
    			return
    		end
    		# ƒAƒjƒ[ƒVƒ‡ƒ“’†‚È‚çƒJ[ƒ\ƒ‹‚̈—‚ðs‚í‚È‚¢
    		return if @command_window.animation?
    		# ªor© ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽê‡
    		if Input.press?(Input::UP) or Input.press?(Input::LEFT)
    			$game_system.se_play($data_system.cursor_se)
    			@command_window.setup_move_move(Window_RingMenu::MODE_MOVEL)
    			return
    		end
    		# «or¨ ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽê‡
    		if Input.press?(Input::DOWN) or Input.press?(Input::RIGHT)
    			$game_system.se_play($data_system.cursor_se)
    			@command_window.setup_move_move(Window_RingMenu::MODE_MOVER)
    			return
    		end
    	end
    	#--------------------------------------------------------------------------
    	# œ ƒtƒŒ[ƒ€XV (ƒXƒe[ƒ^ƒXƒEƒBƒ“ƒhƒE‚ªƒAƒNƒeƒBƒu‚Ìê‡)
    	#--------------------------------------------------------------------------
    	def update_status
    		# B ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽê‡
    		if Input.trigger?(Input::B)
    			# ƒLƒƒƒ“ƒZƒ‹ SE ‚ð‰‰‘t
    			$game_system.se_play($data_system.cancel_se)
    			# ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚ðƒAƒNƒeƒBƒu‚É‚·‚é
    			@command_window.active = true
    			@status_window.active = false
    			@status_window.visible = false
    			@status_window.index = -1
    			return
    		end
    		# C ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽê‡
    		if Input.trigger?(Input::C)
    			# ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚̃J[ƒ\ƒ‹ˆÊ’u‚Å•ªŠò
    			case @command_window.index
    			when 1 # ƒXƒLƒ‹
    				# ‚±‚̃AƒNƒ^[‚Ìs“®§ŒÀ‚ª 2 ˆÈã‚Ìê‡
    				if $game_party.actors[@status_window.index].restriction >= 2
    					# ƒuƒU[ SE ‚ð‰‰‘t
    					$game_system.se_play($data_system.buzzer_se)
    					return
    				end
    				# Œˆ’è SE ‚ð‰‰‘t
    				$game_system.se_play($data_system.decision_se)
    				# ƒXƒLƒ‹‰æ–Ê‚ÉØ‚è‘Ö‚¦
    				$scene = Scene_Skill.new(@status_window.index)
    			when 2 # ‘•”õ
    				# Œˆ’è SE ‚ð‰‰‘t
    				$game_system.se_play($data_system.decision_se)
    				# ‘•”õ‰æ–Ê‚ÉØ‚è‘Ö‚¦
    				$scene = Scene_Equip.new(@status_window.index)
    			when 3 # ƒXƒe[ƒ^ƒX
    				# Œˆ’è SE ‚ð‰‰‘t
    				$game_system.se_play($data_system.decision_se)
    				# ƒXƒe[ƒ^ƒX‰æ–Ê‚ÉØ‚è‘Ö‚¦
    				$scene = Scene_Status.new(@status_window.index)
    			end
    			return
    		end
    	end
    end
    

     

     

×
×
  • Create New...