View difference between Paste ID: fHaPErrw and fbFhUn6s

 #===============================================================================#
-#                          Grid Inventory Script v1.1                           #
+#                          Grid Inventory Script v1.1                          #
 #-------------------------------------------------------------------------------#
-#     Made by DarkSchneider (original script) and Gus (edit and bug fixes)      #
+#   Feito por DarkSchneider (script original) e Gus (edit e conserto de bugs)   #
 #                                     ~~~                                       #
-#         Special credits to Schwarz for draw_line and Blizzard for the         #
+#     Agradecimentos especiais a Schwarz pelo draw_line e à Blizzard pelos      #
-#                     Diablo 1 graphics used in this demo                       #
+#                     gráficos do Diablo 1 usados nesta demo                    #
 #-------------------------------------------------------------------------------#
-#                         Description and instructions                          #
+#                           Descrição e instruções                              #
-#  This script changes the inventory, making it grid-based, inspired on games   #
+#  Este script muda o inventário, transformando ele em um grid. Foi inspirado   #
-#  like Diablo, Resident Evil and Deus Ex. before installing it on your game,   #
+#  em jogos como Diablo, Resident Evil e Deus Ex. Antes de colocar ele no seu   #
-#  MAKE SURE YOU HAVE ADAPTED YOUR DATABASE. All the items should start their   #
+#  jogo, CERTIFIQUE-SE DE QUE VOCÊ ADAPTOU SUA DATABASE. Todos os itens devem   #
-#  names with the format [#x#], being the first number the item width and the   #
+#  começar com o formato [#x#], com o primeiro número sendo a largura do item   #
-#  second number the item height. See the demo's database for more info. Also   #
+#  e o segundo número a altura. Cheque a database da demo se precisar de mais   #
-#  if you have any questions or problems with this script you can email me at   #
+#  informações, e caso você tenha alguma dúvida ou pergunta sobre esse script   #
-#             scripts.gus@gmail.com and I'll try to help you out.               #
+#  mande um email para scripts.gus@gmail.com e eu tentarei te ajudar.           #
 #===============================================================================#
 
 #===============================================================================#
-# Customization variables and some info about them
+# Variáveis customizáveis e informações sobre elas
 #===============================================================================#
 module Grid_Variables
-	# Width of the grid, in number of tiles
+	# Largura do grid, em número de quadros
 	GRID_WIDTH = 19
-	# Height of the grid, in number of tiles
+	# Altura do grid, em número de quadros
 	GRID_HEIGHT = 12
 
-	# Color for items' backgrounds. (Red, Green, Blue, Opacity)
+	# Cor para o fundo dos itens (Vermelho, Verde, Azul, Opacidade)
 	COLOR_ITEMS = Color.new(0,0,200,50)
 	COLOR_WEAPONS = Color.new(200,0,0,50)
 	COLOR_ARMORS = Color.new(0,200,0,50)
 
-	# Important items are items with a price of 0. They can't be sold, and, if
+  # Itens importantes têm um preço de 0. Eles não podem ser vendidos, e se esta
-	# this variable is false, they won't be able to be discarded too.
+  # variável for verdadeira, eles também não vão poder ser descartados.
 	CAN_DROP_IMPORTANT_ITEMS = false
 
-	# Big icons need to be exactly the size the item takes on the script, multi-
+  # Ícones grandes precisam ser exatamente do tamanho do item no script, vezes
-	# plied by 32. Take a look at the icons folder for clarification
+  # 32. Dê uma olhada na pasta de ícones se estiver com dúvidas
 	USE_BIG_ICONS = true
 
-	# The big icons need to use exactly the same name as their item's icon, with
+  # Os ícones grandes precisam ter exatamente o mesmo nome do ícone do item, com
-	# something in front of the name for identification. Default is "grid.".
+  # alguma coisa na frente do nome para identificação. O padrão é "grid.".
-	# IMPORTANT: Set this to "" if you're not using the big icons.
+  # IMPORTANTE: Se não for usar os ícones grandes, mude o valor para ""
 	BIG_ICONS_PREFIX = "grid."
 
-	# The mini help window is the little window that shows the item name. If your
+  # A janela de mini ajuda é aquela janelinha que mostra o nome do item. Se o seu
-	# grid does not takes the entire window, you can set this to true.
+  # grid não toma a janela inteira, você pode deixar esse valor "true'
 	MINIHELP_CAN_BE_OUTSIDE_GRID = false
 
-	# This preferably has to be a 640x480 (or whatever window size you're using)
+  # Essa imagem preferencialmente tem que ser 640x480 (ou a resolução que você)
-	# picture, since it will allow you to change the dimensions without having to
+  # está usando, já que assim você vai poder mudar as dimensões sem ter que editar
-	# edit the picture.
+  # a imagem.
 	GRID_BG_LOCATION = RPG::Cache.picture("gridbg")
 
-	# When you replace an item, and then press esc, it will either do nothing
+  # Quando você substitui um item e depois aperta esc, ou não vai acontecer nada
-	# (play buzzer se) or draw it anywhere. If you want the second, set this
+  # (reproduzir SE de erro) ou ele vai ser colocado onde for possível. Se for
-	# constant to false
+  # false ele vai permitir, true ele não fará nada
 	ALLOW_ESC_REPLACING = false
 end
 
 #===============================================================================#
 # Main class, replaces the original Scene_Item
 #===============================================================================#
 class Scene_Item
 	# The original script tried to use one inventory for each actor, but RPG Maker
-	# doesn't supports that, so this is a workaround, easier than editing a lot of
+  # doesn't supports that, so this is a workaround, easier than editing a lot of
-	# code
+  # code
 	def initialize(actor_index = 0)
 		@actor_index = actor_index
 	end
 
 	def main
-		s1 = "Use"
+		s1 = "Usar"
-		s2 = "Move"
+		s2 = "Mover"
-		s3 = "Drop"
+		s3 = "Jogar"
 		@command_window = Window_Command.new(96, [s1, s2 , s3])
 		@command_window.active = false
 		@command_window.visible = false
 		@command_window.z = 120 # So the icons don't overlap the window
 		@help_window = Window_Help.new
 		@grid = Window_Grid.new(@actor_index)
 		@grid.active = true
 		@grid.set = 0
 		@grid.mode = nil
 		# Associate help window
 		@grid.help_window = @help_window
 		# Make target window (set to invisible / inactive)
 		@target_window = Window_Target.new
 		@target_window.visible = false
 		@target_window.active = false
 		# Make target window for equiping items on the grid
 		@target_equip = Window_Target_Equip.new
 		@target_equip.visible = false
 		@target_equip.active = false
 		# To avoid problems when moving items
 		@moving_item = false
 		@call_methods = ""
 
 		# Execute transition
 		Graphics.transition
 		# Main loop
 		loop do
 			# Update game screen
 			Graphics.update
 			# Update input information
 			Input.update
 			# Frame update
 			update
 			# Abort loop if screen is changed
 			if $scene != self
 				break
 			end
 		end
 		# Prepare for transition
 		Graphics.freeze
 		@cursor_icon.dispose if @cursor_icon != nil
 		# Dispose of windows
 		@command_window.dispose
 		@help_window.dispose
 		@target_window.dispose
 		@target_equip.dispose
 		@grid.dispose
 	end
 	#--------------------------------------------------------------------------
 	# * Frame Update
 	#--------------------------------------------------------------------------
 	def update
 		# Update windows
 		@command_window.update
 		@help_window.update
 		@target_window.update
 		@target_equip.update
 		@grid.update
 		@grid.movingItemUpdate(@moving_item)
 		if @command_window.active
 			# Disabling drop option if item price is 0
 			if !Grid_Variables::CAN_DROP_IMPORTANT_ITEMS
 				if @grid.item.price == 0
 					@command_window.disable_item(2)
 				else
 					@command_window.enable_item(2)
 				end
 			end
 
 			# Disabling use option if item isn't usable
 			if !$game_party.item_can_use?(@grid.item.id) && @grid.item.is_a?(RPG::Item)
 				@command_window.disable_item(0)
 			else
 				@command_window.enable_item(0)
 			end
 
 			update_command
 			return
 		end
 
 		@command_window.x = @grid.x + (@grid.cursor_rect.x + 16) + (@grid.cursor_rect.width)
 		@command_window.y = @grid.y + (@grid.cursor_rect.y + 16) - (@command_window.height/ 2) + (@grid.cursor_rect.height / 2)
 		@command_window.x = @grid.x + @grid.cursor_rect.x - @command_window.width + 16 if @grid.cursor_rect.x + @grid.cursor_rect.height >= ((Grid_Variables::GRID_WIDTH - 2)* 32)
 
 		if @grid.active
 			if Input.trigger?(Input::C) && @grid.item != nil && !@moving_item
 				# Play decision SE
 				$game_system.se_play($data_system.decision_se)
 				@command_window.active = true
 				@command_window.visible = true
 				@grid.active = false
 			end
 
 			# If B button was pressed
 			if Input.trigger?(Input::B) && !@moving_item
 				# Play cancel SE
 				$game_system.se_play($data_system.cancel_se)
 				# Switch to menu screen
 				$scene = Scene_Menu.new(0)
 				return
 			end
 
 			# Some methods have to be called here on the update, so this does the job
 			case @call_methods
 			when "use"
 				use_item
 			when "cancel moving"
 				@cursor_icon = Cursor_Icon.new if @cursor_icon == nil
 				@cursor_icon.visible = false
 			when "move2"
 				@cursor_icon.update
 				update_move2
 			end
 		end
 		if @target_window.active
 			update_target
 			return
 		elsif @target_equip.active
 			update_target_equip
 			return
 		end
 	end
 
 	#--------------------------------------------------------------------------
 	# * Command Window Update
 	#--------------------------------------------------------------------------
 	def update_command
 		if Input.trigger?(Input::B)
 			@command_window.active = false
 			@command_window.visible = false
 			@grid.active = true
 			return
 		end
 		if Input.trigger?(Input::C)
 			# Branch by command window cursor position
 			case @command_window.index
 			when 0 # use
 				# Play decision SE
 				$game_system.se_play($data_system.decision_se)
 				@call_methods = "use"
 			when 1 # move
 				# Play equip SE
 				$game_system.se_play($data_system.equip_se)
 				@cursor_icon = Cursor_Icon.new if @cursor_icon == nil
 				@cursor_icon.visible = false
 				move_item
 			when 2 # drop
 				if @grid.item != nil
 					if !Grid_Variables::CAN_DROP_IMPORTANT_ITEMS
 						if @grid.item.price != 0
 							# Play cancel SE
 							$game_system.se_play($data_system.cancel_se)
 							@grid.delete_item(true)
 						else
 							# Play buzzer SE
 							$game_system.se_play($data_system.buzzer_se)
 						end
 					else
 						@grid.delete_item(true)
 					end
 				end
 			end
 			@command_window.active = false
 			@command_window.visible = false
 			@grid.active = true
 			return
 		end
 	end
 
 	#--------------------------------------------------------------------------
 	# * Frame Update (when item window is active)
 	#--------------------------------------------------------------------------
 	def use_item
 		# Get currently selected data on the item window
 		@item = @grid.item
 		# If it's a weapon or armor
 		if !@item.is_a?(RPG::Item)
 			@grid.active = false
 			@target_equip.x = @grid.x + @grid.cursor_rect.x + (@grid.cursor_rect.width / 2) >= 320 ? 0 : 304
 			@target_equip.visible = true
 			@target_equip.active = true
 			@target_equip.index = 0
 
 			for i in 0...$game_party.actors.size
 				if $game_party.actors[i].equippable?(@item)
 					@target_equip.enable_actor(i)
 				else
 					@target_equip.disable_actor(i)
 				end
 			end
 
 			@target_equip.refresh
 		else
 			# If it can't be used
 			unless $game_party.item_can_use?(@item.id)
 				# Play buzzer SE
 				$game_system.se_play($data_system.buzzer_se)
 				@call_methods = ""
 				return
 			end
 
 			# If effect scope is an ally
 			if @item.scope >= 3
 				# Activate target window
 				@grid.active = false
 				@target_window.x = @grid.x + @grid.cursor_rect.x + (@grid.cursor_rect.width / 2) >= 320 ? 0 : 304
 				@target_window.visible = true
 				@target_window.active = true
 				# Set cursor position to effect scope (single / all)
 				if @item.scope == 4 || @item.scope == 6
 					@target_window.index = -1
 				else
 					@target_window.index = 0
 				end
-				# If effect scope is other than an ally
+			# If effect scope is other than an ally
 			else
 				# If command event ID is valid
 				if @item.common_event_id > 0
 					# Command event call reservation
 					$game_temp.common_event_id = @item.common_event_id
 					# Play item use SE
 					$game_system.se_play(@item.menu_se)
 					# If consumable
 					if @item.consumable
 						# Decrease used items by 1
 						$game_party.eraseDat(@item.id, "i", 1)
 						# Draw item window item
 						@grid.delete_item
 					end
 					# Switch to map screen
 					$scene = Scene_Map.new
 					return
 				end
 			end
 		end
 		@call_methods = ""
 		return
 	end
 	#--------------------------------------------------------------------------
 	# * Frame Update (when target window is active)
 	#--------------------------------------------------------------------------
 	def update_target
 		# If B button was pressed
 		if Input.trigger?(Input::B)
 			# Play cancel SE
 			$game_system.se_play($data_system.cancel_se)
 			# If unable to use because items ran out
 			unless $game_party.item_can_use?(@item.id)
 				# Remake item window contents
 				@grid.refresh
 			end
 			# Erase target window
 			@grid.active = true
 			@target_window.visible = false
 			@target_window.active = false
 			return
 		end
 		# If C button was pressed
 		if Input.trigger?(Input::C)
 			# If items are used up
 			if @grid.item_del?
 				# Play buzzer SE
 				$game_system.se_play($data_system.buzzer_se)
 				return
 			end
 			# If target is all
 			if @target_window.index == -1
 				# Apply item effects to entire party
 				used = false
 				for i in $game_party.actors
 					used |= i.item_effect(@item)
 				end
 			end
 			# If single target
 			if @target_window.index >= 0
 				# Apply item use effects to target actor
 				target = $game_party.actors[@target_window.index]
 				used = target.item_effect(@item)
 			end
 			# If an item was used
 			if used
 				# Play item use SE
 				$game_system.se_play(@item.menu_se)
 				# If consumable
 				if @item.consumable
 					@grid.delete_item(true)
 				end
 				# Remake target window contents
 				@target_window.refresh
 				# If all party members are dead
 				if $game_party.all_dead?
 					# Switch to game over screen
 					$scene = Scene_Gameover.new
 					return
 				end
 				# If common event ID is valid
 				if @item.common_event_id > 0
 					# Common event call reservation
 					$game_temp.common_event_id = @item.common_event_id
 					# Switch to map screen
 					$scene = Scene_Map.new
 					return
 				end
 
 				if Input.trigger?(Input::B)
 					# Erase target window
 					@grid.active = true
 					@target_window.visible = false
 					@target_window.active = false
 					return
 				end
 
 			end
 			# If item wasn't used
 			unless used
 				# Play buzzer SE
 				$game_system.se_play($data_system.buzzer_se)
 			end
 			return
 		end
 	end
 
 	#--------------------------------------------------------------------------
 	# * Frame Update (when target equip window is active)
 	#--------------------------------------------------------------------------
 	def update_target_equip
 		# If B button was pressed
 		if Input.trigger?(Input::B)
 			# Play cancel SE
 			$game_system.se_play($data_system.cancel_se)
 			# If unable to use because items ran out
 			unless $game_party.item_can_use?(@item.id)
 				# Remake item window contents
 				@grid.refresh
 			end
 			# Erase target window
 			@grid.active = true
 			@target_equip.visible = false
 			@target_equip.active = false
 			return
 		end
 
 		# If C button was pressed
 		if Input.trigger?(Input::C)
 			actor = @target_equip.index
 			if @target_equip.disabled?(actor)
 				# Play buzzer SE
 				$game_system.se_play($data_system.buzzer_se)
 				return
 			end
 
 			if @item.is_a?(RPG::Weapon)
 				equipped = $data_weapons[$game_party.actors[actor].weapon_id]
 				type = "w"
 				itemKind = 0
 			elsif @item.is_a?(RPG::Armor)
 				type = "a"
 				itemKind = $data_armors[@item.id].kind + 1 # +1 because weapons are already at index 0
 				case $data_armors[@item.id].kind
 				when 0
 					equipped = $data_armors[$game_party.actors[actor].armor1_id]
 				when 1
 					equipped = $data_armors[$game_party.actors[actor].armor2_id]
 				when 2
 					equipped = $data_armors[$game_party.actors[actor].armor3_id]
 				when 3
 					equipped = $data_armors[$game_party.actors[actor].armor4_id]
 				end
 			else
 				equipped = nil
 			end
 
 			# Check to see if the equipped item and the select item are the same, if
-			# so pretend to switch
+      # so pretend to switch
 			if equipped.id == @item.id
 				# Play equip SE
 				$game_system.se_play($data_system.equip_se)
 				@grid.active = true
 				@target_equip.visible = false
 				@target_equip.active = false
 				@call_methods = ""
 				return
 			end
 
 			# if actor has an item equipped, we need a grid space verification
 			if equipped != nil
 				gridFull = @grid.checkWithoutDeleting(@item.id, type, equipped.id)
 			end
 
 			if !gridFull || equipped == nil
 				# Play equip SE
 				$game_system.se_play($data_system.equip_se)
 				@grid.delete_item
 				$game_party.actors[actor].grid_equip(itemKind, @item == nil ? 0 : @item.id)
 				$game_party.eraseData(type, @item.id, 1)
 				@grid.refresh
 				@grid.active = true
 				@target_equip.visible = false
 				@target_equip.active = false
 				@call_methods = ""
 				return
 			else
 				# Play buzzer SE
 				$game_system.se_play($data_system.buzzer_se)
 			end
 
 			if Input.trigger?(Input::B)
 				# Play cancel SE
 				$game_system.se_play($data_system.cancel_se)
 				@call_methods = ""
 				return
 			end
 			return
 		end
 	end
 
 	#--------------------------------------------------------------------------
 	# * Frame Update (when moving item)
 	#--------------------------------------------------------------------------
 	def move_item
 		if @grid.item != nil
 			@grid.get_item
 			# Setting the bitmaps for the Cursor_Icon
 			if Grid_Variables::USE_BIG_ICONS
 				bitmap = Bitmap.new(@grid.itemWidth * 32, @grid.itemHeight * 32)
 				x, y = 0, 0
 			else
 				bitmap = Bitmap.new(32,32)
 				x, y = 4 + ((@grid.itemWidth * 32) / 2) - 16, 4 + ((@grid.itemHeight * 32) / 2) - 16
 			end
 
 
 			bitmap.blt(0,0,@grid.contents,Rect.new(@grid.cursor_rect.x + x,
 					@grid.cursor_rect.y + y,@grid.cursor_rect.width,@grid.cursor_rect.height))
 
 			@cursor_icon.refresh(bitmap, @grid.itemWidth, @grid.itemHeight)
 			@grid.cursor_rect.width = @cursor_icon.bitmap.width
 			@grid.cursor_rect.height = @cursor_icon.bitmap.height
 			@cursor_icon.x = @grid.cursor_rect.x + @grid.x + 16
 			@cursor_icon.y = @grid.cursor_rect.y + @grid.y + 16
 			@cursor_icon.visible = true
 			@grid.delete_item
 			@moving_item = true
 			@call_methods = "move2"
 		end
 		return
 	end
 
 	#--------------------------------------------------------------------------
 	# * Frame Update (when replacing item)
 	#--------------------------------------------------------------------------
 	def replace_item
 		@grid.updateItemSize
 		@grid.get_item2
 		@grid.delete_item_replace
 		@grid.redraw_item("replace")
 		@grid.transfer_get
 
 		@grid.updateItemSizeFirstDraw(@grid.item_saved[0], @grid.item_saved[1])
 		if @grid.item_saved[1] == "i" || @grid.item_saved[1] == "w" || @grid.item_saved[1] == "a"
 			bitmap = RPG::Cache.icon(Grid_Variables::BIG_ICONS_PREFIX + @grid.item(@grid.item_saved[1], @grid.item_saved[0]).icon_name)
 		else
 			bitmap = Bitmap.new(@grid.itemWidth * 32, @grid.itemHeight * 32)
 		end
 
 		if Grid_Variables::USE_BIG_ICONS
 			x, y = 0, 0
 		else
 			x, y = 4 + ((@grid.itemWidth * 32) / 2) - 16, 4 + ((@grid.itemHeight * 32) / 2) - 16
 		end
 
 		bitmap.blt(0,0,Bitmap.new(@grid.itemWidth * 32, @grid.itemHeight * 32),Rect.new(@grid.item_saved[2] + x,
 				@grid.item_saved[3] + y,@grid.cursor_rect.width,@grid.cursor_rect.height))
 
 		@cursor_icon.refresh(bitmap, @grid.itemWidth, @grid.itemHeight)
 		@grid.cursor_rect.width = @cursor_icon.bitmap.width
 		@grid.cursor_rect.height = @cursor_icon.bitmap.height
 		@cursor_icon.x = @grid.cursor_rect.x + @grid.x + 16
 		@cursor_icon.y = @grid.cursor_rect.y + @grid.y + 16
 		@cursor_icon.visible = true
 		@moving_item2 = true
 		@call_methods = "move2"
 	end
 
 	#--------------------------------------------------------------------------
 	# * Managing the Cursor_Icon and waiting for input
 	#--------------------------------------------------------------------------
 	def update_move2
 		if Input.trigger?(Input::B)
 			if !@moving_item2 # blocks esc if moving a replaced item
 				# Play cancel SE
 				$game_system.se_play($data_system.cancel_se)
 				# Switch to menu screen
 				@grid.redraw_item(false)
 				#@grid.mode = 1
 				@call_methods = "cancel moving"
 				@moving_item = false
 				return
 			elsif @moving_item2 && !Grid_Variables::ALLOW_ESC_REPLACING
 				$game_system.se_play($data_system.cancel_se)
 				if !$game_party.isGridFull?(@grid.item_saved[0], @grid.item_saved[1])
 					pos = $game_party.set_item(@grid.item_saved[0], @grid.item_saved[1], true)
 					@grid.draw_item(@grid.item_saved[0], @grid.item_saved[1], pos[0] , pos[1])
 				else
 					$game_party.eraseData(@grid.item_saved[1], @grid.item_saved[0], 1)
 				end
 				@call_methods = "cancel moving"
 				@moving_item = false
 				@moving_item2 = false
 			else
 				$game_system.se_play($data_system.buzzer_se)
 			end
 		end
 
 		@grid.cursor_rect.width = @cursor_icon.bitmap.width
 		@grid.cursor_rect.height = @cursor_icon.bitmap.height
 		@cursor_icon.x = @grid.cursor_rect.x + @grid.x + 16
 		@cursor_icon.y = @grid.cursor_rect.y + @grid.y + 16
 
 		if @grid.empty?
 			@cursor_icon.blink_on
 			@cursor_icon.tone.set(155,0,0,0)
 		else
 			@cursor_icon.blink_off
 			@cursor_icon.tone.set(155,0,0,255)
 		end
 
 		if Input.trigger?(Input::C)
 			empty = @grid.empty?
 			if empty == true
 				@grid.redraw_item
 				@cursor_icon.visible = false
 
 				# Play equip SE
 				$game_system.se_play($data_system.equip_se)
 
 				@call_methods = ""
 				@moving_item = false
 				@moving_item2 = false
 			elsif empty == "replace"
 				# Play equip SE
 				$game_system.se_play($data_system.equip_se)
 				@call_methods = ""
 				replace_item
 			else
 				$game_system.se_play($data_system.buzzer_se)
 			end
 			return
 		end
 	end
 end
 
 #===============================================================================#
 # This edit removes the [#x#] from the item name, and passes it to $data_grid
 #===============================================================================#
 class Scene_Title
 	alias old_main main
 	def main
 		old_main
 
 		$data_grid = [], [], [] # index 0: items, 1: weapons, 2: armors
 
 		# Looping three times, each time for a different item type
 		for i in 0..2
 			case i
 			when 0
 				type = $data_items
 			when 1
 				type = $data_weapons
 			when 2
 				type = $data_armors
 			end
 
 			# Editing the item name and adding the item size to the grid
 			for j in 0..type.length - 1
 				if type[j] != nil && type[j].name[0,1] == "["
 					$data_grid[i][j] = type[j].name.match(/\[(.*)\]/)[1]
 					type[j].name = type[j].name.gsub(/\[(.*)\]/, "").lstrip
 				end
 			end
 		end
 	end
 end
 
 #===============================================================================#
 # This edit is to avoid losing money when buying more itens than you can carry.
 # You will only be able to buy a number of items until your inventory is full,
 # and you will only be charged for those items.
 #===============================================================================#
 class Scene_Shop
 	#--------------------------------------------------------------------------
 	# * Frame Update
 	#--------------------------------------------------------------------------
 	def buy_item(item, number)
 		if !$game_party.isGridFull?(item.id, "", item)
 
 			case item
 			when RPG::Item
 				amountBought = $game_party.gain_item(item.id, number)
 			when RPG::Weapon
 				amountBought = $game_party.gain_weapon(item.id, number)
 			when RPG::Armor
 				amountBought = $game_party.gain_armor(item.id, number)
 			end
 
 			if amountBought != nil
 				number = amountBought - 1
 			end
 
 			$game_party.lose_gold(number * @item.price)
 			$game_system.se_play($data_system.shop_se)
 		else
 			$game_system.se_play($data_system.buzzer_se)
 			@buy_window.gridFull
 		end
 	end
 
 	# Edit to use buy_item instead of the default way
 	def update_number
 		if Input.trigger?(Input::B)
 			$game_system.se_play($data_system.cancel_se)
 			@number_window.active = false
 			@number_window.visible = false
 			case @command_window.index
 			when 0  # Buy
 				@buy_window.active = true
 				@buy_window.visible = true
 			when 1  # Sell
 				@sell_window.active = true
 				@sell_window.visible = true
 				@status_window.visible = false
 			end
 			return
 		end
 		if Input.trigger?(Input::C)
 			@number_window.active = false
 			@number_window.visible = false
 			case @command_window.index
 			when 0  # Buy
 				buy_item(@item, @number_window.number)
 				@gold_window.refresh
 				@status_window.refresh
 				@buy_window.active = true
 				@buy_window.visible = true
 			when 1  # Sell
 				$game_system.se_play($data_system.shop_se)
 				$game_party.gain_gold(@number_window.number * (@item.price / 2))
 				case @item
 				when RPG::Item
 					$game_party.lose_item(@item.id, @number_window.number)
 				when RPG::Weapon
 					$game_party.lose_weapon(@item.id, @number_window.number)
 				when RPG::Armor
 					$game_party.lose_armor(@item.id, @number_window.number)
 				end
 				@gold_window.refresh
 				@sell_window.refresh
 				@status_window.refresh
 				@sell_window.active = true
 				@sell_window.visible = true
 				@status_window.visible = false
 			end
 			return
 		end
 	end
 end
 
 #===============================================================================#
 # This edit is to show "Inventory is full!" on the shop help window
 #===============================================================================#
 class Window_ShopBuy < Window_Selectable
 	def update_help
 		# Removing the message if player presses up or down
 		if @gridIsFull
 			if Input.trigger?(Input::UP) || Input.trigger?(Input::DOWN)
 				@gridIsFull = false
 			end
 		end
 
 		@help_window.set_text(self.item == nil ? "" : self.item.description)
-		@help_window.set_text("Inventory is full!") if @gridIsFull
+		@help_window.set_text("Inventário está cheio!") if @gridIsFull
 	end
 
 	# Setting this for remote access later
 	def gridFull
 		@gridIsFull = true
 	end
 end
 
 #===============================================================================#
 # This edit is to show "Inventory is full!" on the equip help window
 #===============================================================================#
 class Scene_Equip
 	def update_item
 		# Se o botão B for pressionado
 		if Input.trigger?(Input::B)
 			# Reproduzir SE de cancelamento
 			$game_system.se_play($data_system.cancel_se)
 			# Ativar janela da direita
 			@right_window.active = true
 			@item_window.active = false
 			@item_window.index = -1
 			return
 		end
 		# Se o botão C for pressionado
 		if Input.trigger?(Input::C)
 			# Reproduzir SE de Equipamento
 			$game_system.se_play($data_system.equip_se)
 			# Selecionar dados escolhidos na janela de Item
 			item = @item_window.item
 			# Mudar Equipamento
 			equip = @actor.equip(@right_window.index, item == nil ? 0 : item.id)
 			@right_window.gridFull if equip == nil
 			# Ativar janela da direita
 			@right_window.active = true
 			@item_window.active = false
 			@item_window.index = -1
 			# Recriar os conteúdos da janela de Itens e da direita
 			@right_window.refresh
 			@item_window.refresh
 			return
 		end
 	end
 end
 
 #===============================================================================#
 # Same as above
 #===============================================================================#
 class Window_EquipRight < Window_Selectable
 	def update_help
 		if @gridIsFull
 			if Input.trigger?(Input::UP) || Input.trigger?(Input::DOWN)
 				@gridIsFull = false
 			end
 		end
 		@help_window.set_text(self.item == nil ? "" : self.item.description)
-		@help_window.set_text("Inventory is full!") if @gridIsFull
+		@help_window.set_text("Inventário está cheio!") if @gridIsFull
 	end
 
 	def gridFull
 		@gridIsFull = true
 	end
 end
 
 #===============================================================================#
 # This is an edit to enable a command window item after it has been disabled. As
 # far as I know there is no default way to do this.
 #===============================================================================#
 class Window_Command < Window_Selectable
 	def enable_item(index)
 		draw_item(index, normal_color)
 	end
 end
 
 #===============================================================================#
 # This edit changes the behavior of Window_Selectable if the grid is active
 #===============================================================================#
 class Window_Selectable < Window_Base
 	alias old_initialize initialize
 	def initialize(x, y, width, height)
 		old_initialize(x, y, width, height)
 		if self.is_a?(Window_Grid)
 			@x = 0
 			@y = 0
 		end
 	end
 
 	alias old_update update
 	def update
 		if !self.is_a?(Window_Grid)
 			old_update
 			return
 		end
 		super
 
 		item = $game_party.actors[@actor_index].item_grid
 
 		# If cursor is movable
 		if self.active and @x >= 0
 			# Using special directional commands if the user is moving an item. Without
-			# this sometimes you might get crashes when moving items, since the script
+      # this sometimes you might get crashes when moving items, since the script
-			# can "teleport" your cursor to a coordinate that doesn't exists.
+      # can "teleport" your cursor to a coordinate that doesn't exists.
 			if self.movingItem?
 				if Input.repeat?(Input::DOWN)
 					if @y == item.size - @itemHeight
 						@y = 0
 					else
 						@y += 1
 					end
 
 					$game_system.se_play($data_system.cursor_se)
 				end
 				if Input.repeat?(Input::UP)
 					if @y == 0
 						@y = item.size - @itemHeight
 					else
 						@y -= 1
 					end
 
 					$game_system.se_play($data_system.cursor_se)
 				end
 				if Input.repeat?(Input::RIGHT)
 					if @x == item[@y].size - @itemWidth
 						@x = 0
 					else
 						@x += 1
 					end
 					$game_system.se_play($data_system.cursor_se)
 				end
 				if Input.repeat?(Input::LEFT)
 					if @x == 0
 						@x = item[@y].size - @itemWidth
 					else
 						@x -= 1
 					end
 
 					$game_system.se_play($data_system.cursor_se)
 				end
 			else
 				# This makes the cursor select the entire item, no matter which slot it
-				# is in
+        # is in
 				if item[@y][@x][1][0,1] == "["
 					itemSplit = item[@y][@x][1].gsub(/[\[\]]/, "").split('x')
 					iH = itemSplit[0].to_i
 					iW = itemSplit[1].to_i
 					@x -= iW
 					@y -= iH
 				end
 
 				if Input.repeat?(Input::DOWN)
 					# if @y is at the last tile or above an item that is covering the last
-					# tile (and this item exists)
+          # tile (and this item exists)
 					if @y == item.size - 1 || (@y == item.size - @itemHeight && item[@y][@x][1] != "")
 						@y = 0
 					else
 						@y += item[@y][@x][1] != "" ? @itemHeight : 1 #if the current slot is an item, add the item height, else add 1
 					end
 
 					$game_system.se_play($data_system.cursor_se)
 				end
 
 				if Input.repeat?(Input::UP)
 					# since whenever the item is selected the @y goes to the top tile,
-					# there's no need for special checks
+          # there's no need for special checks
 					if @y == 0
 						@y = item.size - 1
 					else
 						@y -= 1
 					end
 
 					$game_system.se_play($data_system.cursor_se)
 				end
 
 				if Input.repeat?(Input::RIGHT)
 					# if @x is at the last tile or above an item that is covering the last
-					# tile (and this item exists)
+          # tile (and this item exists)
 					if @x == item[@y].size - 1 || (@x == item[@y].size - @itemWidth && item[@y][@x][1] != "")
 						@x = 0
 					else
 						@x += item[@y][@x][1] != "" ? @itemWidth : 1 #if the current slot is an item, add the item height, else add 1
 					end
 
 					$game_system.se_play($data_system.cursor_se)
 				end
 
 				if Input.repeat?(Input::LEFT)
 					# since whenever the item is selected the @x goes to the top-left tile,
-					# there's no need for special checks
+          # there's no need for special checks
 					if @x == 0
 						@x = item[@y].size - 1
 					else
 						@x -= 1
 					end
 
 					$game_system.se_play($data_system.cursor_se)
 				end
 			end
 		end
 		# Update help text (update_help is defined by the subclasses)
 		if self.active and @help_window != nil
 			update_help
 		end
 		# Update cursor rectangle
 		update_cursor_rect
 	end
 
 	def hide_cursor
 		self.cursor_rect.empty
 	end
 end
 
 #===============================================================================#
 # The main grid window
 #===============================================================================#
 class Window_Grid < Window_Selectable
 
 	attr_accessor :mode
 	attr_reader :itemWidth
 	attr_reader :itemHeight
 	attr_reader :item_saved
 	attr_reader :item_saved2
 
 	def initialize(actor_index)
 		# This will center the grid. Feel free to edit it if you don't want that
 		super((640/2)-(((Grid_Variables::GRID_WIDTH * 32) + 32) / 2), # x
 			32 + (480 / 2) - (((Grid_Variables::GRID_HEIGHT * 32) + 32) / 2), # y
 			(Grid_Variables::GRID_WIDTH * 32)+33, # width
 			(Grid_Variables::GRID_HEIGHT * 32)+33) # height
 
 		self.contents = Bitmap.new(width - 32, height - 32)
 		self.opacity = 0
 		# This window does nothing, it's there just to replace the otherwise black
-		# background.
+    # background.
 		@dummy_window = Window_Base.new(0, 64, 640, 480 - 64)
 		@dummy_window.z = 0
 		@window = Window_Base.new(x , y , width, height)
 		@window.contents = Bitmap.new(width - 32, height - 32)
 		@window.z = self.z - 4
 		@window.opacity = 0
 		@grid_color = Sprite.new
 		@grid_color.bitmap = Bitmap.new(width - 32, height - 32)
 		@grid_color.x = self.x + 16
 		@grid_color.y = self.y + 16
 		@grid_color.z = @window.z + 2
 		@actor_index = actor_index
 		@mode = 0
 		@mini_help = Mini_Help.new
 		self.set = -1
 		n = self.contents.width / 32
 		m = self.contents.height / 32
 		@column_max = n
 		draw_grid
 		@itemWidth = 1
 		@itemHeight = 1
 		@movingItem = false
 		refresh
 	end
 
 	def draw_grid
 		gridHeight = Grid_Variables::GRID_HEIGHT * 32
 		gridWidth = Grid_Variables::GRID_WIDTH * 32
 		# Creates the window bg
 		@window.contents.blt(0, 0, Grid_Variables::GRID_BG_LOCATION, Rect.new(0, 0, gridWidth, gridHeight))
 		i = 0
 		color = Color.new(150,150,150)
 		while i <= gridHeight
 			draw_line(-1, i, gridWidth + 1, i, color)
 			i += 32
 		end
 		i = 0
 		while i <= gridWidth
 			draw_line(i, 0, i, gridHeight, color)
 			i += 32
 		end
 	end
 
 	def draw_line(sx, sy, ex, ey, color)
 		rad = Math.atan2(ey-sy, ex-sx)
 		dx = Math.cos(rad)
 		dy = Math.sin(rad)
 		while (sx - ex).abs > 1 || (sy - ey).abs > 1
 			sx += dx
 			sy += dy
 			@window.contents.set_pixel(sx, sy, color)
 		end
 	end
 
 	def refresh
 		@item_max = 0
 		item = $game_party.actors[@actor_index].item_grid
 		for i in 0..item.size - 1
 			for j in 0..item[i].size - 1
 				if item[i][j][0] == 0 and (item[i][j][1] == "i" or item[i][j][1] == "w" or item[i][j][1] == "a")
 					@item_max += 1
 				end
 			end
 		end
 
 		for i in 0..item.size - 1
 			for j in 0..item[i].size - 1
 				draw_item(item[i][j][0], item[i][j][1], i , j)
 			end
 		end
 	end
 
 	# Updates the @movingItem variable. Mostly used on remote access
 	def movingItemUpdate(moving_item)
 		@movingItem = moving_item
 	end
 
 	# Returns true or false, depending on @movingItem. Mostly used on remote access
 	def movingItem?
 		movingItemUpdate(@movingItem)
 		return @movingItem
 	end
 
 
 	def update_cursor_rect
 		# @x is the cursor's x
 		if @x < 0
 			self.cursor_rect.empty
 			return
 		end
 
 		# Assign the parameters in the item's name to the cursor
 		if item != nil
 			updateItemSize if !@movingItem
 			cursor_width = @itemWidth * 32
 			cursor_height = @itemHeight * 32
 		else
 			# Default values in case the item name has no parameters
 			case $game_party.actors[@actor_index].item_grid[@y][@x][1]
 			when "i" # Item, uses 1x1
 				cursor_width = 32
 				cursor_height = 32
 			when "w" # Weapon, uses 1x3
 				cursor_width = 32
 				cursor_height = 96
 			when "a" # Armor, uses 2x3
 				cursor_width = 64
 				cursor_height = 96
 			else
 				cursor_width = 32
 				cursor_height = 32
 			end
 		end
 
 
 		# Calculate cursor coordinates
 		x = @x * 32
 		y = @y * 32
 
 		# Update cursor rectangle
 		self.cursor_rect.set(x, y, cursor_width, cursor_height)
 	end
 
 	# Deletes the item from the grid. If removeData is true, also removes the item
-	# from inventory.
+  # from inventory.
 	def delete_item(removeData = false)
 		type = $game_party.actors[@actor_index].item_grid[@y][@x][1]
 		item_id = $game_party.actors[@actor_index].item_grid[@y][@x][0]
 		if type != ""	|| type[0,1] != "["
 			iH, iW = 0, 0
 			@grid_color.bitmap.fill_rect(@x*32+1, @y*32+1, (@itemWidth * 32) - 1, (@itemHeight * 32) - 1, Color.new(0,0,0,0))
 			self.contents.fill_rect(@x*32, @y*32, @itemWidth*32, @itemHeight*32, Color.new(0,0,0,0))
 
 			for iH in 0...@itemHeight.to_i
 				for iW in 0...@itemWidth.to_i
 					$game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][0] = 0
 					$game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][1] = ""
 					#iW = 0
 				end
 			end
 		end
 
 		if removeData
 			$game_party.eraseData(type, item_id, 1)
 		end
 	end
 
 	# This is a special delete_item, using the @item_saved array as parameters
 	def delete_item_replace
 		item_id = @item_saved2[0]
 		type = @item_saved2[1]
 		itemX = @item_saved2[2]
 		itemY = @item_saved2[3]
 		if type != ""
 			updateItemSizeFirstDraw(item_id, type)
 			@grid_color.bitmap.fill_rect((itemX)*32+1, (itemY)*32+1, (@itemWidth * 32) - 1, (@itemHeight * 32) - 1, Color.new(0,0,0,0))
 			self.contents.fill_rect((itemX)*32, (itemY)*32, @itemWidth*32, @itemHeight*32, Color.new(0,0,0,0))
 
 			for iH in 0...@itemHeight.to_i
 				for iW in 0...@itemWidth.to_i
 					$game_party.actors[@actor_index].item_grid[itemY + iH][itemX + iW][0] = 0
 					$game_party.actors[@actor_index].item_grid[itemY + iH][itemX + iW][1] = ""
 				end
 			end
 		end
 	end
 
 	# This iis a method for the grid equip feature. It "pretends" to delete the
-	# item to see if there is enough space to unequip the equipped item.
+  # item to see if there is enough space to unequip the equipped item.
 	def checkWithoutDeleting(item_id, type, equip_id)
 		for iH in 0...@itemHeight.to_i
 			for iW in 0...@itemWidth.to_i
 				$game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][0] = 0
 				$game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][1] = ""
 			end
 		end
 
 		flag = $game_party.isGridFull?(equip_id, type)
 
 		for iH in 0...@itemHeight.to_i
 			for iW in 0...@itemWidth.to_i
 				if iH == 0 && iW == 0
 					$game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][0] = item_id
 					$game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][1] = type
 				else
 					$game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][0] = item_id
 					$game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][1] = "[#{iH}x#{iW}]"
 				end
 			end
 		end
 		return flag
 	end
 
 	# Updating the @itemWidth and @itemHeight variables
 	def updateItemSize
 		if item != nil && itemSize != nil
 			gridValues = itemSize.split('x')
 			@itemWidth = gridValues[0].to_i
 			@itemHeight = gridValues[1].to_i
 		else
 			@itemWidth = 0
 			@itemHeight = 0
 		end
 	end
 
 	# Manually updating the @itemWidth and @itemHeight variables.
 	def updateItemSizeFirstDraw(item_id, type)
 		item = itemSize(item_id, type)
 
 		if item != nil
 			gridValues = item.split('x')
 			@itemWidth = gridValues[0].to_i
 			@itemHeight = gridValues[1].to_i
 		end
 	end
 
 	# Checking the item type and returning the correct $data
 	def item(type = nil, id = nil)
 		if type == nil && id == nil
 			id = $game_party.actors[@actor_index].item_grid[@y][@x][0]
 			type = $game_party.actors[@actor_index].item_grid[@y][@x][1]
 		end
 
 		case type
 		when "i"
 			return $data_items[id]
 		when "w"
 			return $data_weapons[id]
 		when "a"
 			return $data_armors[id]
 		else
 			return nil
 		end
 	end
 
 	# Returns the item size from the $data_grid variables
 	def itemSize(id = nil, type = nil)
 		if type == nil && id == nil
 			id = $game_party.actors[@actor_index].item_grid[@y][@x][0]
 			type = $game_party.actors[@actor_index].item_grid[@y][@x][1]
 		end
 
 		case type
 		when "i"
 			return $data_grid[0][id]
 		when "w"
 			return $data_grid[1][id]
 		when "a"
 			return $data_grid[2][id]
 		else return nil
 		end
 	end
 
 	# Checking if the item is unusable or not, I guess. This was here on the
-	# original script
+  # original script
 	def item_del?
 		if $game_party.actors[@actor_index].item_grid[@y][@x][0] == 0
 			# Unusable
 			return true
 		else
 			return false
 		end
 	end
 
 	def dispose
 		super
 		@window.dispose
 		@dummy_window.dispose
 		@grid_color.dispose
 		@mini_help.dispose
 	end
 
 	# Updating the help window (with item description) and the mini_help (with
-	# item name)
+  # item name)
 	def update_help
 		@mini_help.contents.font.color = (($game_party.item_can_use?(item.id) || !item.is_a?(RPG::Item))? normal_color : disabled_color)
 		@help_window.set_text((item == nil || movingItem? == true) ? "" : item.description)
 		@mini_help.set_text(item == nil ? "" : item.name)
 		@mini_help.visible = false if item == nil || movingItem?
 
 		@mini_help.x = self.x + (self.cursor_rect.x + 16) - (@mini_help.width / 2) + (self.cursor_rect.width / 2)
 		@mini_help.y = self.y + (self.cursor_rect.y + 16) + (self.cursor_rect.height)
 
 		if !Grid_Variables::MINIHELP_CAN_BE_OUTSIDE_GRID
 			@mini_help.x += (@mini_help.x - self.x - 16) * -1 if @mini_help.x < self.x + 16 # -16 to make it look good even if you hide the windowskin
 			@mini_help.x -= (@mini_help.x + @mini_help.width) - (self.x + self.width - 16) if @mini_help.x + @mini_help.width >= self.x + self.width - 16
 			@mini_help.y -= self.cursor_rect.height + @mini_help.height - 1 if @mini_help.y + @mini_help.height >= self.y + self.height - 16
 		end
 	end
 
 	# Stores the item data on an array, and keeps them safe while moving the item.
 	def get_item
 		@item_saved = [$game_party.actors[@actor_index].item_grid[@y][@x][0],
 			$game_party.actors[@actor_index].item_grid[@y][@x][1], @x, @y]
 	end
 
 	# Same thing as above, but with some added precautions to make sure it gets
-	# the	right @x and @y. Used for the replace item method.
+  # the	right @x and @y. Used for the replace item method.
 	def get_item2
 		updateItemSizeFirstDraw(@item_saved[0], @item_saved[1])
 
 		iH, iW = 0, 0
 		if $game_party.actors[@actor_index].item_grid[@y][@x][0] == 0
 			for iW in 0...@itemWidth.to_i
 				for iH in 0...@itemHeight.to_i
 					if $game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][0] != 0
 						break
 					end
 				end
 				break if $game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][0] != 0
 			end
 		end
 
 		if $game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][1][0,1] == "["
 			itemSplit = $game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][1].gsub(/[\[\]]/, "").split('x')
 			minusH = itemSplit[0].to_i
 			minusW = itemSplit[1].to_i
 		else
 			minusH = 0
 			minusW = 0
 		end
 
 		item_id = $game_party.actors[@actor_index].item_grid[@y + iH - minusH][@x + iW - minusW][0]
 		type = $game_party.actors[@actor_index].item_grid[@y + iH - minusH][@x + iW - minusW][1]
 		@item_saved2 = [item_id, type, @x + iW - minusW, @y + iH - minusH]
 	end
 
 	# Clears the @item_saved and transfers the data on @item_saved2 to it
 	def transfer_get
 		@item_saved = []
 		@item_saved2.each{|i| @item_saved.push(i)}
 	end
 
 	# Redrawing used for moving items. Using @item_saved parameters if moving was
 	# canceled (f = false)
 	def redraw_item(f = true)
 		if f
 			x = 4 + (@x * 32)
 			y = @y * 32
 		else # the moving has been canceled
 			x = 4 + (@item_saved[2] * 32)
 			y = @item_saved[3] * 32
 			tx = @x
 			ty = @y
 			@x = @item_saved[2]
 			@y = @item_saved[3]
 		end
 
 		draw_item(@item_saved[0], @item_saved[1], @y, @x)
 		for iH in 0...@itemHeight.to_i
 			for iW in 0...@itemWidth.to_i
 				if iH == 0 && iW == 0
 					$game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][0] = @item_saved[0]
 					$game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][1] = @item_saved[1]
 				else
 					$game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][0] = @item_saved[0]
 					$game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][1] = "[#{iH}x#{iW}]"
 				end
 			end
 		end
 
 		# Making the cursor go to the replaced item
 		if f == "replace"
 			@x = @item_saved2[2]
 			@y = @item_saved2[3]
 		end
 
 		# Uncomment these lines if you don't want the cursor to go back with the
 		# item when the player cancels moving.
 		#@x = tx if @x != tx and tx != nil
 		#@y = ty if @y != ty and ty != nil
 	end
 
 	# Checks if the cursor area is empty, and if there is more than one item on it
 	def empty?
 		n = 0
 		arr = []
 		for iH in 0...@itemHeight.to_i
 			for iW in 0...@itemWidth.to_i
 				type = $game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][1]
 				id = $game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][0]
 				cond = (type == "")
 				replaceable = true if !cond
 
 				if !cond && (type == "i" || type == "w" || type == "a") && arr[n-1] != "#{@y + iH},#{@x + iW}"
 					n += 1
 					arr.push("#{@y + iH},#{@x + iW}")
 				end
 				if type[0,1] == "["
 					itemSplit = type.gsub(/[\[\]]/, "").split('x')
 					minusH = itemSplit[0].to_i
 					minusW = itemSplit[1].to_i
 
 					if arr[n-1] != "#{@y + iH - minusH},#{@x + iW - minusW}"
 						n += 1
 						arr.push("#{@y + iH - minusH},#{@x + iW - minusW}")
 					end
 				end
 				break if n >= 2
 			end
 			break if n >= 2
 		end
 		return "replace" if replaceable && n < 2
 		return (n < 2 && !replaceable)
 	end
 
-	def set=(set)
+  def set=(set)
 		@x = set
 		@y = set
 		@mini_help.visible = (set == 0 ? true : false)
 	end
 
 	# Draws item graphics
 	def draw_item(item_id, type, i , j)
 		#~ if type == "i" and
 		#~ $game_party.item_can_use?($data_items[item_id].id)
 		opacity = 255
 		#~ else
 		#~ opacity = 128
 		#~ end
 
 		if item_id != 0
 			x = 4 + (j * 32)
 			y = i * 32
 			itemWeaponArmor = item(type, item_id)
 
 			case type
 			when "i"
 				color = Grid_Variables::COLOR_ITEMS
 			when "w"
 				color = Grid_Variables::COLOR_WEAPONS
 			when "a"
 				color = Grid_Variables::COLOR_ARMORS
 			end
 
 			if type != "" && type[0,1] != "["
 				x = j * 32
 				y = i * 32
 				updateItemSizeFirstDraw(item_id, type)
 				bitmap = RPG::Cache.icon(Grid_Variables::BIG_ICONS_PREFIX + itemWeaponArmor.icon_name)
 
 				if Grid_Variables::USE_BIG_ICONS && (bitmap.width != 24 && bitmap.height != 24)
 					self.contents.blt(x, y, bitmap, Rect.new(0, 0, @itemWidth * 32, @itemHeight * 32), opacity)
 				else
 					x += ((@itemWidth * 32) / 2) - 16
 					y += ((@itemHeight * 32) / 2) - 16
 					self.contents.blt(x + 4, y + 4, bitmap, Rect.new(0, 0, 48, 24), opacity)
 				end
 
 				@grid_color.bitmap.fill_rect(j*32+1, i*32+1, (@itemWidth * 32) - 1, (@itemHeight * 32) - 1, color)
 			end
 		end
 	end
 end
 
 #==============================================================================
 # This is Window_Target, edited to darken actors that can't equip the item.
 # Since there is no way to change the normal color on Window_Base, I had to
 # rewrite most draw functions here.
 #==============================================================================
 class Window_Target_Equip < Window_Selectable
 
 	def initialize
 		super(0, 0, 336, 480)
 		self.contents = Bitmap.new(width - 32, height - 32)
 		self.contents.font.name = $fontface
 		self.contents.font.size = $fontsize
 		self.z += 10
 		@item_max = $game_party.actors.size
 		@disabled_actor = []
 		refresh
 	end
 
 	def refresh
 		self.contents.clear
 		for i in 0...$game_party.actors.size
 			disabled = @disabled_actor[i]
 			if disabled
 				self.contents.font.color = disabled_color
 			else
 				self.contents.font.color = normal_color
 			end
 
 			x = 4
 			y = i * 116
 			actor = $game_party.actors[i]
 
 			# actor name
 			self.contents.draw_text(x, y, 120, 32, actor.name)
 
 			# actor class
 			self.contents.draw_text(x + 144, y, 236, 32, actor.class_name)
 
 			# actor level
 			self.contents.font.color = system_color if !disabled
 			self.contents.draw_text(x + 8, y + 32, 32, 32, "Lv")
 			self.contents.font.color = normal_color if !disabled
 			self.contents.draw_text(x + 8 + 32, y + 32, 24, 32, actor.level.to_s, 2)
 
 			# actor state
 			text = make_battler_state_text(actor, width, true)
 			self.contents.font.color = knockout_color if actor.hp == 0 && !disabled
 			self.contents.draw_text(x + 8, y + 64, width, 32, text)
 			self.contents.font.color = normal_color if actor.hp == 0 && !disabled
 
 			# actor hp
 			self.contents.font.color = system_color if !disabled
 			self.contents.draw_text(x + 152, y + 32, 32, 32, $data_system.words.hp)
 			# Checking if there is enough space for max HP
 			if 144 - 32 >= 108
 				hp_x = x + 152 + 144 - 108
 				flag = true
 			elsif 144 - 32 >= 48
 				hp_x = x + 152 + 144 - 48
 				flag = false
 			end
 			# Draw HP
 			if !disabled
 				if actor.hp == 0
 					self.contents.font.color = knockout_color
 				elsif actor.hp <= actor.maxhp / 4
 					self.contents.font.color = crisis_color
 				else
 					self.contents.font.color = normal_color
 				end
 			end
 			self.contents.draw_text(hp_x, y + 32, 48, 32, actor.hp.to_s, 2)
 			# Draw max HP
 			if flag
 				self.contents.font.color = normal_color if !disabled
 				self.contents.draw_text(hp_x + 48, y + 32, 12, 32, "/", 1)
 				self.contents.draw_text(hp_x + 60, y + 32, 48, 32, actor.maxhp.to_s)
 			end
 
 			# actor sp
 			self.contents.font.color = system_color if !disabled
 			self.contents.draw_text(x + 152, y + 64, 32, 32, $data_system.words.sp)
 			# Check if there is enough space for max SP
 			if 144 - 32 >= 108
 				sp_x = x + 152+ 144 - 108
 				flag = true
 			elsif 144 - 32 >= 48
 				sp_x = x + 152+ 144 - 48
 				flag = false
 			end
 			# Draw SP
 			if !disabled
 				if actor.sp == 0
 					self.contents.font.color = knockout_color
 				elsif actor.sp <= actor.maxsp / 4
 					self.contents.font.color = crisis_color
 				else
 					self.contents.font.color = normal_color
 				end
 			end
 			self.contents.draw_text(sp_x, y + 64, 48, 32, actor.sp.to_s, 2)
 			# Draw max SP
 			if flag
 				self.contents.font.color = normal_color if !disabled
 				self.contents.draw_text(sp_x + 48, y + 64, 12, 32, "/", 1)
 				self.contents.draw_text(sp_x + 60, y + 64, 48, 32, actor.maxsp.to_s)
 			end
 		end
 	end
 
 	def update_cursor_rect
 		# Se define a posição atual -1
 		if @index < 0
 			self.cursor_rect.set(0, 0, self.width - 32, @item_max * 116 - 20)
 		else
 			self.cursor_rect.set(0, @index * 116, self.width - 32, 96)
 		end
 	end
 
 	def disable_actor(actor_id)
 		@disabled_actor[actor_id] = true
 	end
 
 	def enable_actor(actor_id)
 		@disabled_actor[actor_id] = false
 	end
 
 	def disabled?(id)
 		return @disabled_actor[id]
 	end
 end
 
 #==============================================================================
 # The mini help window shows the item name below the selection cursor
 #==============================================================================
 class Mini_Help < Window_Base
 	alias old_initialize initialize
 	def initialize
 		super(0, 0, 180, 43)
 		self.contents = Bitmap.new(width - 32, height - 32)
 		self.contents.font.size = 14
 		self.back_opacity = 170
 		self.z = 102
 		self.visible = false
 	end
 
 	def set_text(text, align = 1)
 		# If at least one part of text and alignment differ from last time
 		if text != @text or align != @align
 			# Redraw text
 			self.contents.clear
 			#self.contents.font.color = normal_color
 			self.contents.draw_text(4, -12, self.width - 40, 32, text, align)
 			#self.width = self.contents.text_size(text).width
 			@text = text
 			@align = align
 			@actor = nil
 		end
 		self.visible = true
 	end
 end
 
 #==============================================================================
 # Changes the way the game handles item creation
 #==============================================================================
 class Game_Actor < Game_Battler
 	attr_accessor :item_grid
 	alias old_initialize initialize
 	def initialize(actor_id)
 		old_initialize(actor_id)
 		@item_grid = Array.new(Grid_Variables::GRID_HEIGHT)
 		for i in 0..@item_grid.size - 1
 			@item_grid[i] = Array.new(Grid_Variables::GRID_WIDTH)
 			for k in 0..@item_grid[i].size - 1
 				@item_grid[i][k] = Array.new(2)
 				@item_grid[i][k][0] = 0
 				@item_grid[i][k][1] = ""
 			end
 		end
 	end
 
 	# This edit is to avoid losing the item if your inventory is already full.
 	def equip(equip_type, id)
 		case equip_type
 		when 0  # Weapons
 			if id == 0 or $game_party.weapon_number(id) > 0
 				$game_party.lose_weapon(id, 1)
 				if !$game_party.isGridFull?(@weapon_id, "w") || @weapon_id == 0
 					$game_party.gain_weapon(@weapon_id, 1)
 					@weapon_id = id
 				else
 					$game_party.gain_weapon(id, 1)
 					$game_system.se_play($data_system.buzzer_se)
 					return nil
 				end
 			end
 		when 1  # Shield
 			if id == 0 or $game_party.armor_number(id) > 0
 				$game_party.lose_armor(id, 1)
 				if !$game_party.isGridFull?(@armor1_id, "a") || @armor1_id == 0
 					update_auto_state($data_armors[@armor1_id], $data_armors[id])
 					$game_party.gain_armor(@armor1_id, 1)
 					@armor1_id = id
 				else
 					$game_party.gain_armor(id, 1)
 					return nil
 				end
 			end
 		when 2  # Headgear
 			if id == 0 or $game_party.armor_number(id) > 0
 				$game_party.lose_armor(id, 1)
 				if !$game_party.isGridFull?(@armor2_id, "a") || @armor2_id == 0
 					update_auto_state($data_armors[@armor2_id], $data_armors[id])
 					$game_party.gain_armor(@armor2_id, 1)
 					@armor2_id = id
 				else
 					$game_party.gain_armor(id, 1)
 					return nil
 				end
 			end
 		when 3  # Armor
 			if id == 0 or $game_party.armor_number(id) > 0
 				$game_party.lose_armor(id, 1)
 				if !$game_party.isGridFull?(@armor3_id, "a") || @armor3_id == 0
 					update_auto_state($data_armors[@armor3_id], $data_armors[id])
 					$game_party.gain_armor(@armor3_id, 1)
 					@armor3_id = id
 				else
 					$game_party.gain_armor(id, 1)
 					return nil
 				end
 			end
 		when 4  # Accessory
 			if id == 0 or $game_party.armor_number(id) > 0
 				$game_party.lose_armor(id, 1)
 				if !$game_party.isGridFull?(@armor4_id, "a") || @armor4_id == 0
 					update_auto_state($data_armors[@armor4_id], $data_armors[id])
 					$game_party.gain_armor(@armor4_id, 1)
 					@armor4_id = id
 				else
 					$game_party.gain_armor(id, 1)
 					return nil
 				end
 			end
 		end
 	end
 
 	# Same as above, but without deleting item. This one is used for the grid equip
 	def grid_equip(equip_type, id)
 		case equip_type
 		when 0  # Armas
 			if id == 0 or $game_party.weapon_number(id) > 0
 				$game_party.gain_weapon(@weapon_id, 1)
 				@weapon_id = id
 			end
 		when 1  # Escudo
 			if id == 0 or $game_party.armor_number(id) > 0
 				update_auto_state($data_armors[@armor1_id], $data_armors[id])
 				$game_party.gain_armor(@armor1_id, 1)
 				@armor1_id = id
 			end
 		when 2  # Elmo
 			if id == 0 or $game_party.armor_number(id) > 0
 				update_auto_state($data_armors[@armor2_id], $data_armors[id])
 				$game_party.gain_armor(@armor2_id, 1)
 				@armor2_id = id
 			end
 		when 3  # Armadura
 			if id == 0 or $game_party.armor_number(id) > 0
 				update_auto_state($data_armors[@armor3_id], $data_armors[id])
 				$game_party.gain_armor(@armor3_id, 1)
 				@armor3_id = id
 			end
 		when 4  # Acessório
 			if id == 0 or $game_party.armor_number(id) > 0
 				update_auto_state($data_armors[@armor4_id], $data_armors[id])
 				$game_party.gain_armor(@armor4_id, 1)
 				@armor4_id = id
 			end
 		end
 	end
 end
 
 #==============================================================================
 # Handles most of the grid inventory functions
 #==============================================================================
 class Game_Party
 	# These have been edited for the Scene_Shop. If it returns something, that
-	# means the grid is full and it couldn't add more items, so we use that number
+  # means the grid is full and it couldn't add more items, so we use that number
-	# to charge for the items bought
+  # to charge for the items bought
 	def gain_item(item_id, n)
 		if item_id > 0
 			if n.abs == n # if the number is a positive value, add the items
 				for k in 1..n
 					break if set_item(item_id, "i") == nil
 				end
 				return k unless k == n
 			else # if the number is a negative value, remove the items
 				lose_item(item_id, n.abs)
 			end
 		end
 	end
 
 	def gain_weapon(weapon_id, n)
 		if weapon_id > 0
 			if n.abs == n # if the number is a positive value, add the items
 				for k in 1..n
 					break if set_item(weapon_id, "w") == nil
 				end
 				return k unless k == n
 			else # if the number is a negative value, remove the items
 				lose_weapon(weapon_id, n.abs)
 			end
 		end
 	end
 
 	def gain_armor(armor_id, n)
 		if armor_id > 0
 			if n.abs == n # if the number is a positive value, add the items
 				for k in 1..n
 					break if set_item(armor_id, "a") == nil
 				end
 				return k unless k == n
 			else # if the number is a negative value, remove the items
 				lose_armor(armor_id, n.abs)
 			end
 		end
 	end
 
 	def lose_item(item_id, n, random = true)
-	def lose_item(item_id, n)
+		if random == true
 			if item_id > 0
-			for k in 1..n
+
-				del_item(item_id, "i")
+					del_item(item_id, "i")
 				end
 			end
 		end
 		@items[item_id] = [[item_number(item_id) + -n, 0].max, 99].min
 	end
-	def lose_weapon(weapon_id, n)
+
 	def lose_weapon(weapon_id, n, random = true)
-			for k in 1..n
+		if random == true
-				del_item(weapon_id, "w")
+			if weapon_id > 0
 				for k in 1..n
 					del_item(weapon_id, "w")
 				end
 			end
 		end
-	def lose_armor(armor_id, n)
+
 	end
-			for k in 1..n
+
-				del_item(armor_id, "a")
+	def lose_armor(armor_id, n, random = true)
 		if random == true
 			if armor_id > 0
 				for k in 1..n
 					del_item(armor_id, "a")
 				end
 			end
 		end
 		@armors[armor_id] = [[armor_number(armor_id) + -n, 0].max, 99].min
 	end
 
 	# Mostly used for the delete_item method. This removes the item from the inventory.
 	def eraseData(type, item_id, n)
 		case type
 		when "i"
 			@items[item_id] = [[item_number(item_id) + -n, 0].max, 99].min
 		when "w"
 			@weapons[item_id] = [[weapon_number(item_id) + -n, 0].max, 99].min
 		when "a"
 			@armors[item_id] = [[armor_number(item_id) + -n, 0].max, 99].min
 		end
 	end
 
 	# Update item properties
 	def updateItemProp(type, item_id)
 		case type
 		when "i"
 			name = $data_grid[0][item_id]
 		when "w"
 			name = $data_grid[1][item_id]
 		when "a"
 			name = $data_grid[2][item_id]
 		else
 			name = nil
 		end
 
 		if name != nil
 			gridValues = name.split('x')
 			@itemWidth = gridValues[0].to_i
 			@itemHeight = gridValues[1].to_i
 		end
 	end
 
 	# Checks if x and y are empty
 	def isEmpty?(x, y)
 		for iH in 0...@itemHeight.to_i
 			for iW in 0...@itemWidth.to_i
 				cond = (self.actors[0].item_grid[x + iH][y + iW][0] == 0)
 				break if !cond
 			end
 			break if !cond
 		end
 		return cond
 	end
 
 	# Checking if there is enough space for the item on the grid
 	def isGridFull?(item_id, type, item = false)
 		if type == "" && item != false
 			case item
 			when RPG::Item
 				type = "i"
 			when RPG::Weapon
 				type = "w"
 			when RPG::Armor
 				type = "a"
 			end
 		end
 
 		if item == false
 			updateItemProp(type, item_id)
 		else
 			case type
 			when "i"
 				name = $data_grid[0][item_id]
 			when "w"
 				name = $data_grid[1][item_id]
 			when "a"
 				name = $data_grid[2][item_id]
 			else
 				name = nil
 			end
 
 			if name != nil
 				gridValues = name.split('x')
 				@itemWidth = gridValues[0].to_i
 				@itemHeight = gridValues[1].to_i
 			end
 		end
 
 
 		for a in 0..self.actors[0].item_grid.size - 1
 			for b in 0..self.actors[0].item_grid[a].size - 1
 				if b < self.actors[0].item_grid[a].size - (@itemWidth.to_i - 1) and a < self.actors[0].item_grid.size - (@itemHeight.to_i - 1)
 					cond = isEmpty?(a, b)
 					break if cond
 				end
 			end
-	# Checking if the grid is full for multiple items
+
-	def isGridFullMultipleItems?(arrayOfIds, types)
+
-		# Just a little precaution, in case the user forgets the square brackets
+
-		arrayOfIds = [arrayOfIds] if !arrayOfIds.kind_of?(Array)
+
 
-		for i in 0..arrayOfIds.length - 1
+  # Checking if the grid is full for multiple items
-			item_id = arrayOfIds[i]
+  def isGridFullMultipleItems?(arrayOfIds, types)
-			if types.length == 1
+    # Just a little precaution, in case the user forgets the square brackets
-				type = types
+    arrayOfIds = [arrayOfIds] if !arrayOfIds.kind_of?(Array)
 
-				type = types[i]
+    for i in 0..arrayOfIds.length - 1
       item_id = arrayOfIds[i]
       if types.length == 1
         type = types
       else
         type = types[i]
       end
 
       case type
       when "i"
         name = $data_grid[0][item_id]
       when "w"
         name = $data_grid[1][item_id]
       when "a"
         name = $data_grid[2][item_id]
       else
         name = nil
       end
 
       if name != nil
-			for a in 0..self.actors[0].item_grid.size - 1
+        gridValues = name.split('x')
-				for b in 0..self.actors[0].item_grid[a].size - 1
+        @itemWidth = gridValues[0].to_i
-					if b < self.actors[0].item_grid[a].size - (@itemWidth.to_i - 1) and a < self.actors[0].item_grid.size - (@itemHeight.to_i - 1)
+        @itemHeight = gridValues[1].to_i
-						cond = isEmpty?(a, b)
+      end
-						break if cond
+
       for a in 0..self.actors[0].item_grid.size - 1
         for b in 0..self.actors[0].item_grid[a].size - 1
-				break if cond
+          if b < self.actors[0].item_grid[a].size - (@itemWidth.to_i - 1) and a < self.actors[0].item_grid.size - (@itemHeight.to_i - 1)
             cond = isEmpty?(a, b)
             break if cond
           end
-		return !cond
+        end
         break if cond
       end
       break if !cond
     end
     return !cond
   end
 
 	# Adds the item values to the grid
 	def set_item(item_id, type, returnPos = false)
 		for a in 0..self.actors[0].item_grid.size - 1
 			for b in 0..self.actors[0].item_grid[a].size - 1
 				updateItemProp(type, item_id)
 				iW = 0; iH = 0
 				if b < self.actors[0].item_grid[a].size - (@itemWidth.to_i - 1) and a < self.actors[0].item_grid.size - (@itemHeight.to_i - 1)
 					if isEmpty?(a, b)
 						for iH in 0...@itemHeight.to_i
 							for iW in 0...@itemWidth.to_i
 								if iH == 0 && iW == 0
 									self.actors[0].item_grid[a][b][0] = item_id
 									self.actors[0].item_grid[a][b][1] = type
 								else
 									self.actors[0].item_grid[a + iH][b + iW][0] = item_id
 									self.actors[0].item_grid[a + iH][b + iW][1] = "[#{iH}x#{iW}]"
 								end
 							end
 						end
 						whatToReturn = ""
 						case type
 						when "i"
 							@items[item_id] = [[item_number(item_id) + 1, 0].max, 99].min
 						when "w"
 							@weapons[item_id] = [[weapon_number(item_id) + 1, 0].max, 99].min
 						when "a"
 							@armors[item_id] = [[armor_number(item_id) + 1, 0].max, 99].min
 						end
 						break
 					else
 						whatToReturn = nil
 					end
 				end
 			end
 			break if whatToReturn != nil
 		end
 
 		return [a, b] if returnPos
 		return whatToReturn
 	end
 
 	# Deletes the item values from the grid
 	def del_item(item_id, type)
 		updateItemProp(type, item_id)
 		for a in 0..self.actors[0].item_grid.size - 1
 			for b in 0..self.actors[0].item_grid[a].size - 1
 				if self.actors[0].item_grid[a][b][0] == item_id and self.actors[0].item_grid[a][b][1] == type
 					for iH in 0...@itemHeight.to_i
 						for iW in 0...@itemWidth.to_i
 							self.actors[0].item_grid[a + iH][b + iW][0] = 0
 							self.actors[0].item_grid[a + iH][b + iW][1] = ""
 						end
 					end
 					return
 				end
 			end
 		end
 	end
 end
 
 #==============================================================================
 # This is the cursor used when moving the item.
 #==============================================================================
 class Cursor_Icon < RPG::Sprite
 	def initialize
 		super
 		@color = Color.new(255,255,0,50)
 		@rect = Rect.new(0, 0, 24, 24)
 	end
 
 	def refresh(bitmap, iW, iH)
 		if Grid_Variables::USE_BIG_ICONS
 			x = 0
 			y = 0
 			@rect = Rect.new(0, 0, iW*32, iH*32)
 		else
 			x = 4 + ((iW * 32) / 2) - 16
 			y = 4 + ((iH * 32) / 2) - 16
 		end
 
 		width = iW * 32
 		height = iH * 32
 
 		if self.bitmap == nil or (self.bitmap.width != width or self.bitmap.height != height)
 			self.bitmap = Bitmap.new(width, height)
 		else
 			self.bitmap.clear
 		end
 		self.bitmap.fill_rect(0,0,width,height, @color)
 		self.bitmap.blt(x, y, bitmap, @rect)
 		self.z = 9999
 	end
 end