1 résultat trouvé pour -------------------------------------------------------------------------------

#===============================================================================#
#                          Grid Inventory Script v1.1                           #
#-------------------------------------------------------------------------------#
#     Made by DarkSchneider (original script) and Gus (edit and bug fixes)      #
#                                     ~~~                                       #
#         Special credits to Schwarz for draw_line and Blizzard for the         #
#                     Diablo 1 graphics used in this demo                       #
#-------------------------------------------------------------------------------#
#                         Description and instructions                          #
#  This script changes the inventory, making it grid-based, inspired on games   #
#  like Diablo, Resident Evil and Deus Ex. before installing it on your game,   #
#  MAKE SURE YOU HAVE ADAPTED YOUR DATABASE. All the items should start their   #
#  names with the format [#x#], being the first number the item width and the   #
#  second number the item height. See the demo's database for more info. Also   #
#  if you have any questions or problems with this script you can email me at   #
#             scripts.gus@gmail.com and I'll try to help you out.               #
#===============================================================================#

#===============================================================================#
# Customization variables and +some info about them
#===============================================================================#
module Grid_Variables
# Width of the grid, in number of tiles
GRID_WIDTH = 8
# Height of the grid, in number of tiles
GRID_HEIGHT = 6

# Color for items' backgrounds. (Red, Green, Blue, Opacity)
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
# this variable is false, they won't be able to be discarded too.
CAN_DROP_IMPORTANT_ITEMS = false

# Big icons need to be exactly the size the item takes on the script, multi-
# plied by 32. Take a look at the icons folder for clarification
USE_BIG_ICONS = true

# The big icons need to use exactly the same name as their item's icon, with
# something in front of the name for identification. Default is "grid.".
# IMPORTANT: Set this to "" if you're not using the big icons.
BIG_ICONS_PREFIX = "grid."

# The mini help window is the little window that shows the item name. If your
# grid does not takes the entire window, you can set this to true.
MINIHELP_CAN_BE_OUTSIDE_GRID = false

# This preferably has to be a 640x480 (or whatever window size you're using)
# picture, since it will allow you to change the dimensions without having to
# edit the picture.
GRID_BG_LOCATION = RPG::Cache.picture("gridbg")

# When you replace an item, and then press esc, it will either do nothing
# (play buzzer se) or draw it anywhere. If you want the second, set this
# constant to false
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
# code
def initialize(actor_index = 0)
@actor_index = actor_index
end

def main
s1 = "Util"
s2 = "Depl"
s3 = "jeter"
@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
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.eraseData(@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
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
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
#---------------------------------------------------------------------------
   # Scene_Equip.update_item
   #---------------------------------------------------------------------------
   # As update_item from the default scene equip, except compares selected
   # actors level to the requirements set in the variables above
   #---------------------------------------------------------------------------
  def update_item
# Se o botão B for pressionado
if Input.trigger?(Input::B)
# Reproduzir SE de cancelamento
&#36;game_system.se_play(&#36;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
&#36;game_system.se_play(&#36;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
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 scr&#105;pt
# 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

&#36;game_system.se_play(&#36;data_system.cursor_se)
end
if Input.repeat?(Input::UP)
if @y == 0
@y = item.size - @itemHeight
else
@y -= 1
end

&#36;game_system.se_play(&#36;data_system.cursor_se)
end
if Input.repeat?(Input::RIGHT)
if @x == item[@y].size - @itemWidth
@x = 0
else
@x += 1
end
&#36;game_system.se_play(&#36;data_system.cursor_se)
end
if Input.repeat?(Input::LEFT)
if @x == 0
@x = item[@y].size - @itemWidth
else
@x -= 1
end

&#36;game_system.se_play(&#36;data_system.cursor_se)
end
else
# This makes the cursor select the entire item, no matter which slot it
# 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)
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

&#36;game_system.se_play(&#36;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
if @y == 0
@y = item.size - 1
else
@y -= 1
end

&#36;game_system.se_play(&#36;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)
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

&#36;game_system.se_play(&#36;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
if @x == 0
@x = item[@y].size - 1
else
@x -= 1
end

&#36;game_system.se_play(&#36;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.
@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 = &#36;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 &#36;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.
def delete_item(removeData = false)
type = &#36;game_party.actors[@actor_index].item_grid[@y][@x][1]
item_id = &#36;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
&#36;game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][0] = 0
&#36;game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][1] = ""
#iW = 0
end
end
end

if removeData
&#36;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
&#36;game_party.actors[@actor_index].item_grid[itemY + iH][itemX + iW][0] = 0
&#36;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.
def checkWithoutDeleting(item_id, type, equip_id)
for iH in 0...@itemHeight.to_i
for iW in 0...@itemWidth.to_i
&#36;game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][0] = 0
&#36;game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][1] = ""
end
end

flag = &#36;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
&#36;game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][0] = item_id
&#36;game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][1] = type
else
&#36;game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][0] = item_id
&#36;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 &#36;data
def item(type = nil, id = nil)
if type == nil && id == nil
id = &#36;game_party.actors[@actor_index].item_grid[@y][@x][0]
type = &#36;game_party.actors[@actor_index].item_grid[@y][@x][1]
end

case type
when "i"
return &#36;data_items[id]
when "w"
return &#36;data_weapons[id]
when "a"
return &#36;data_armors[id]
else
return nil
end
end

# Returns the item size from the &#36;data_grid variables
def itemSize(id = nil, type = nil)
if type == nil && id == nil
id = &#36;game_party.actors[@actor_index].item_grid[@y][@x][0]
type = &#36;game_party.actors[@actor_index].item_grid[@y][@x][1]
end

case type
when "i"
return &#36;data_grid[0][id]
when "w"
return &#36;data_grid[1][id]
when "a"
return &#36;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 scr&#105;pt
def item_del?
if &#36;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)
def update_help
@mini_help.contents.font.color = ((&#36;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 = [&#36;game_party.actors[@actor_index].item_grid[@y][@x][0],
&#36;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.
def get_item2
updateItemSizeFirstDraw(@item_saved[0], @item_saved[1])

iH, iW = 0, 0
if &#36;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 &#36;game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][0] != 0
break
end
end
break if &#36;game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][0] != 0
end
end

if &#36;game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][1][0,1] == "["
itemSplit = &#36;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 = &#36;game_party.actors[@actor_index].item_grid[@y + iH - minusH][@x + iW - minusW][0]
type = &#36;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
&#36;game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][0] = @item_saved[0]
&#36;game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][1] = @item_saved[1]
else
&#36;game_party.actors[@actor_index].item_grid[@y + iH][@x + iW][0] = @item_saved[0]
&#36;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)
@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
#~ &#36;game_party.item_can_use?(&#36;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
# 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)
if item_id > 0
for k in 1..n
del_item(item_id, "i")
end
end
@items[item_id] = [[item_number(item_id) + -n, 0].max, 99].min
end

def lose_weapon(weapon_id, n)
if weapon_id > 0
for k in 1..n
del_item(weapon_id, "w")
end
end
@weapons[weapon_id] = [[weapon_number(weapon_id) + -n, 0].max, 99].min
end

def lose_armor(armor_id, n)
if armor_id > 0
for k in 1..n
del_item(armor_id, "a")
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 = &#36;data_grid[0][item_id]
when "w"
name = &#36;data_grid[1][item_id]
when "a"
name = &#36;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 = &#36;data_grid[0][item_id]
when "w"
name = &#36;data_grid[1][item_id]
when "a"
name = &#36;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
break if cond
end
return !cond #!cond to make it return true if the grid is really full, just to avoid confusion with the method name
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
item_id = arrayOfIds[i]
if types.length == 1
type = types
else
type = types[i]
end

case type
when "i"
name = &#36;data_grid[0][item_id]
when "w"
name = &#36;data_grid[1][item_id]
when "a"
name = &#36;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

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
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