Seperate Items For Actors

[SephirothSpawn]

Seperate Items For Actors
by SephirothSpawn
Version: 1 (2.02.06)

This is a locked, single-post thread from Creation Asylum. Archived here to prevent its loss.
No support is given.

Introduction

Lets You assing Character's Items, that only they can access in the Battle System

Features

• Press 1 - 4 to Assign Weapons to Actors in Party (In item window)
  
• Press C in Item Cache Scene, to Un-Assign Items from Characters
  
• Press A in the Item scene to jump to the item Cache Scene, and A to go back
  
• Lets Battlers Use items only for them within battle. Cannot access party items in battle.
  
• Supports Animated Character Sprites or Battlers
  

Screenshots


Demo

  Katzbalger_Request.zip (Size: 209.29 KB / Downloads: 6)


Script

Code:

#==============================================================================
# Seperate Items For Actors
#==============================================================================
# SephirothSpawn
# Version 1
# 2.02.06
# Thanks to Near Fantastica for his Keyboard Module, and  Katzbalger for requesting it
#==============================================================================

#------------------------------------------------------------------------------
# * SDK Log Script
#------------------------------------------------------------------------------
SDK.log("Seperate Items For Actors", "SephirothSpawn", 1, "2.02.06")

#------------------------------------------------------------------------------
# * Begin SDK Enable Test
#------------------------------------------------------------------------------
if SDK.state("Seperate Items For Actors") == true
  
#==============================================================================
# ** Keyboard Input Module
#==============================================================================
# Near Fantastica
# Version 5
# 29.11.05
#==============================================================================
# The Keyboard Input Module is designed to function as the default Input module
# dose. It is better then other methods keyboard input because as a key is
# tested it is not removed form the list. so you can test the same key multiple
# times the same loop.
#==============================================================================

module Keyboard
  #--------------------------------------------------------------------------
  @keys = []
  @pressed = []
  Mouse_Left = 1
  Mouse_Right = 2
  Back= 8
  Tab = 9
  Enter = 13
  Shift = 16
  Ctrl = 17
  Alt = 18
  Esc = 27
  Space = 32
  Numberkeys = {}
  Numberkeys[0] = 48
  Numberkeys[1] = 49
  Numberkeys[2] = 50
  Numberkeys[3] = 51
  Numberkeys[4] = 52
  Numberkeys[5] = 53
  Numberkeys[6] = 54
  Numberkeys[7] = 55
  Numberkeys[8] = 56
  Numberkeys[9] = 57
  Numberpad = {}
  Numberpad[0] = 45
  Numberpad[1] = 35
  Numberpad[2] = 40
  Numberpad[3] = 34
  Numberpad[4] = 37
  Numberpad[5] = 12
  Numberpad[6] = 39
  Numberpad[7] = 36
  Numberpad[8] = 38
  Numberpad[9] = 33
  Letters = {}
  Letters["A"] = 65
  Letters["B"] = 66
  Letters["C"] = 67
  Letters["D"] = 68
  Letters["E"] = 69
  Letters["F"] = 70
  Letters["G"] = 71
  Letters["H"] = 72
  Letters["I"] = 73
  Letters["J"] = 74
  Letters["K"] = 75
  Letters["L"] = 76
  Letters["M"] = 77
  Letters["N"] = 78
  Letters["O"] = 79
  Letters["P"] = 80
  Letters["Q"] = 81
  Letters["R"] = 82
  Letters["S"] = 83
  Letters["T"] = 84
  Letters["U"] = 85
  Letters["V"] = 86
  Letters["W"] = 87
  Letters["X"] = 88
  Letters["Y"] = 89
  Letters["Z"] = 90
  Fkeys = {}
  Fkeys[1] = 112
  Fkeys[2] = 113
  Fkeys[3] = 114
  Fkeys[4] = 115
  Fkeys[5] = 116
  Fkeys[6] = 117
  Fkeys[7] = 118
  Fkeys[8] = 119
  Fkeys[9] = 120
  Fkeys[10] = 121
  Fkeys[11] = 122
  Fkeys[12] = 123
  Collon = 186
  Equal = 187
  Comma = 188
  Underscore = 189
  Dot = 190
  Backslash = 191
  Lb = 219
  Rb = 221
  Quote = 222
  State = Win32API.new("user32","GetKeyState",['i'],'i')
  Key = Win32API.new("user32","GetAsyncKeyState",['i'],'i')
  #--------------------------------------------------------------------------
  def Keyboard.getstate(key)
    return true unless State.call(key).between?(0, 1)
    return false
  end
  #--------------------------------------------------------------------------
  def Keyboard.testkey(key)
    Key.call(key) & 0x01 == 1
  end
  #--------------------------------------------------------------------------
  def Keyboard.update
    @keys = []
    @keys.push(Keyboard::Mouse_Left) if Keyboard.testkey(Keyboard::Mouse_Left)
    @keys.push(Keyboard::Mouse_Right) if Keyboard.testkey(Keyboard::Mouse_Right)
    @keys.push(Keyboard::Back) if Keyboard.testkey(Keyboard::Back)
    @keys.push(Keyboard::Tab) if Keyboard.testkey(Keyboard::Tab)
    @keys.push(Keyboard::Enter) if Keyboard.testkey(Keyboard::Enter)
    @keys.push(Keyboard::Shift) if Keyboard.testkey(Keyboard::Shift)
    @keys.push(Keyboard::Ctrl) if Keyboard.testkey(Keyboard::Ctrl)
    @keys.push(Keyboard::Alt) if Keyboard.testkey(Keyboard::Alt)
    @keys.push(Keyboard::Esc) if Keyboard.testkey(Keyboard::Esc)
    @keys.push(Keyboard::Space) if Keyboard.testkey(Keyboard::Space)
    for key in Keyboard::Numberkeys.values
      @keys.push(key) if Keyboard.testkey(key)
    end
    for key in Keyboard::Numberpad.values
      @keys.push(key) if Keyboard.testkey(key)
    end
    for key in Keyboard::Letters.values
      @keys.push(key) if Keyboard.testkey(key)
    end
    for key in Keyboard::Fkeys.values
      @keys.push(key) if Keyboard.testkey(key)
    end
    @keys.push(Keyboard::Collon) if Keyboard.testkey(Keyboard::Collon)
    @keys.push(Keyboard::Equal) if Keyboard.testkey(Keyboard::Equal)
    @keys.push(Keyboard::Comma) if Keyboard.testkey(Keyboard::Comma)
    @keys.push(Keyboard::Underscore) if Keyboard.testkey(Keyboard::Underscore)
    @keys.push(Keyboard::Dot) if Keyboard.testkey(Keyboard::Dot)
    @keys.push(Keyboard::Backslash) if Keyboard.testkey(Keyboard::Backslash)
    @keys.push(Keyboard::Lb) if Keyboard.testkey(Keyboard::Lb)
    @keys.push(Keyboard::Rb) if Keyboard.testkey(Keyboard::Rb)
    @keys.push(Keyboard::Quote) if Keyboard.testkey(Keyboard::Quote)
    @pressed = []
    @pressed.push(Keyboard::Mouse_Left) if Keyboard.getstate(Keyboard::Mouse_Left)
    @pressed.push(Keyboard::Mouse_Right) if Keyboard.getstate(Keyboard::Mouse_Right)
    @pressed.push(Keyboard::Back) if Keyboard.getstate(Keyboard::Back)
    @pressed.push(Keyboard::Tab) if Keyboard.getstate(Keyboard::Tab)
    @pressed.push(Keyboard::Enter) if Keyboard.getstate(Keyboard::Enter)
    @pressed.push(Keyboard::Shift) if Keyboard.getstate(Keyboard::Shift)
    @pressed.push(Keyboard::Ctrl) if Keyboard.getstate(Keyboard::Ctrl)
    @pressed.push(Keyboard::Alt) if Keyboard.getstate(Keyboard::Alt)
    @pressed.push(Keyboard::Esc) if Keyboard.getstate(Keyboard::Esc)
    @pressed.push(Keyboard::Space) if Keyboard.getstate(Keyboard::Space)
    for key in Keyboard::Numberkeys.values
      @pressed.push(key) if Keyboard.getstate(key)
    end
    for key in Keyboard::Numberpad.values
      @pressed.push(key) if Keyboard.getstate(key)
    end
    for key in Keyboard::Letters.values
      @pressed.push(key) if Keyboard.getstate(key)
    end
    for key in Keyboard::Fkeys.values
      @pressed.push(key) if Keyboard.getstate(key)
    end
    @pressed.push(Keyboard::Collon) if Keyboard.getstate(Keyboard::Collon)
    @pressed.push(Keyboard::Equal) if Keyboard.getstate(Keyboard::Equal)
    @pressed.push(Keyboard::Comma) if Keyboard.getstate(Keyboard::Comma)
    @pressed.push(Keyboard::Underscore) if Keyboard.getstate(Keyboard::Underscore)
    @pressed.push(Keyboard::Dot) if Keyboard.getstate(Keyboard::Dot)
    @pressed.push(Keyboard::Backslash) if Keyboard.getstate(Keyboard::Backslash)
    @pressed.push(Keyboard::Lb) if Keyboard.getstate(Keyboard::Lb)
    @pressed.push(Keyboard::Rb) if Keyboard.getstate(Keyboard::Rb)
    @pressed.push(Keyboard::Quote) if Keyboard.getstate(Keyboard::Quote)
  end
  #--------------------------------------------------------------------------
  def Keyboard.trigger?(key)
    return true if @keys.include?(key)
    return false
  end
  #--------------------------------------------------------------------------
  def Keyboard.pressed?(key)
    return true if @pressed.include?(key)
    return false
  end
end

#==============================================================================
# ** Bitmap
#==============================================================================

class Bitmap
  #--------------------------------------------------------------------------
  # * Scale Blt
  #--------------------------------------------------------------------------
  def scale_blt(dest_rect, src_bitmap,
    src_rect = Rect.new(0, 0, src_bitmap.width, src_bitmap.height), opacity = 255)
    w, h = src_rect.width, src_rect.height
    scale = [w / dest_rect.width.to_f, h / dest_rect.height.to_f].max
    ow, oh = (w / scale).to_i, (h / scale).to_i
    ox, oy = (dest_rect.width - ow) / 2, (dest_rect.height - oh) / 2
    stretch_blt(Rect.new(ox + dest_rect.x, oy + dest_rect.y, ow, oh),
      src_bitmap, src_rect )
  end
end

#==============================================================================
# ** Game_Party
#==============================================================================

class Game_Party
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :items
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  alias seph_individualactorcache_gameparty_item_number item_number
  #--------------------------------------------------------------------------
  # * Get Number of Items Possessed
  #     item_id : item ID
  #--------------------------------------------------------------------------
  def item_number(item_id)
    # If In Battle, loads Active Battler Numbers
    if $game_temp.in_battle
      n = 0
      for item in $scene.active_battler.item_cache
        if item.id == item_id
          n += 1
        end
      end
      return n
    else
      # If quantity data is in the hash, use it. If not, return 0
      return @items.include?(item_id) ? @items[item_id] : 0
    end
  end
end

#==============================================================================
# ** Game_Actor
#==============================================================================

class Game_Actor
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :item_cache
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  alias seph_individualactorcache_gameactor_setup setup
  #--------------------------------------------------------------------------
  # * Setup
  #--------------------------------------------------------------------------
  def setup(actor_id)
    # Sets Item Cache
    @item_cache = []
    # Original Actor Setup Method
    seph_individualactorcache_gameactor_setup(actor_id)
  end
  #--------------------------------------------------------------------------
  # * Assign Item
  #     item_id : Items ID #
  #--------------------------------------------------------------------------
  def assign_item(item_id)
    item = $data_items[item_id]
    unless item.nil?
      @item_cache << item
      @item_cache.sort! {|a, b| a.id<=>b.id}
      item_number = $game_party.items.include?(item_id) ? $game_party.items[item_id] : 0
      $game_party.items[item_id] = [[item_number - 1, 0].max, 99].min
    end
  end
  #--------------------------------------------------------------------------
  # * Unassign Item
  #     item_id : Items ID #
  #--------------------------------------------------------------------------
  def unassign_item(item_id)
    item = $data_items[item_id]
    unless item.nil?
      if @item_cache.include?(item)
        use_item(item_id)
        $game_party.gain_item(item_id, 1)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Use Item
  #     item_id : Items ID #
  #--------------------------------------------------------------------------
  def use_item(item_id)
    item = $data_items[item_id]
    unless item.nil?
      for i in 0...@item_cache.size
        if item == @item_cache[i]
          @item_cache.delete_at(i)
          break
        end
      end
    end
  end
end

#==============================================================================
# ** Scene_Battle
#==============================================================================

class Scene_Battle
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader :active_battler
end

#==============================================================================
# ** Window_Item
#==============================================================================

class Window_Item < Window_Selectable
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    # For Out Of Battle Use
    unless $game_temp.in_battle
      # Add item
      for i in 1...$data_items.size
        if $game_party.item_number(i) > 0
          @data.push($data_items[i])
        end
      end
      # Adds In Actor Item Cache
      for actor in $game_party.actors
        for item in actor.item_cache
          @data << item unless @data.include?(item)
        end
      end
      # Also add weapons and items if outside of battle
      for i in 1...$data_weapons.size
        if $game_party.weapon_number(i) > 0
          @data.push($data_weapons[i])
        end
      end
      for i in 1...$data_armors.size
        if $game_party.armor_number(i) > 0
          @data.push($data_armors[i])
        end
      end
    # For In Battle Use
    else
      for item in $scene.active_battler.item_cache
        @data << item
      end
    end
    # If item count is not 0, make a bit map and draw all items
    @item_max = @data.size
    if @item_max > 0
      self.contents = Bitmap.new(width - 32, row_max * 32)
      for i in 0...@item_max
        draw_item(i)
      end
    end
  end
end

#==============================================================================
# ** Window_ItemCacheHeading
#==============================================================================

class Window_ItemCacheHeading < Window_Base
  #--------------------------------------------------------------------------
  # * Constant
  #--------------------------------------------------------------------------
  DRAW_CHARACTER = true
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(actor_index)
    super(actor_index * 160, 64, 160, 160)
    self.contents = Bitmap.new(width - 32, height - 32)
    @frame = 0
    refresh(@actor = $game_party.actors[actor_index])
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh(actor = @actor)
    self.contents.clear
    @actor = actor
    return if @actor.nil?
    # Draws Actors Name
    self.contents.draw_text(4, 0, contents.width - 8, 32, @actor.name, 1)
    # Draws Actors Sprite
    if DRAW_CHARACTER
      draw_sprite(0, 32, 128, 96, @actor.character_name, @actor.character_hue, 0, @frame)
    else
      bitmap = RPG::Cache.battler(@actor.battler_name, @actor.battler_hue)
      self.contents.scale_blt(Rect.new(0, 32, 128, 96), bitmap)
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super
    # If Character Sprite
    if DRAW_CHARACTER
      if Graphics.frame_count % 10 == 0
        @frame == 3 ? @frame = 0 : @frame += 1
        refresh
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Sprite
  #--------------------------------------------------------------------------
  def draw_sprite(x, y, w, h, name, hue, stance, frame)
    # Gets Bitmap
    bitmap = RPG::Cache.character(name, hue)
    # Bitmap Division
    cw, ch = bitmap.width / 4,  bitmap.height / 4
    # Gets Animation Offsets
    x_off, y_off = cw * frame, ch * stance
    # Draws Bitmap
    self.contents.scale_blt(Rect.new(x, y, w, h), bitmap, Rect.new(x_off, y_off, cw, ch))
  end
end

#==============================================================================
# ** Window_ItemCache
#==============================================================================

class Window_ItemCache < Window_Selectable
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(actor_index)
    super(actor_index * 160, 224, 160, 256)
    @actor = $game_party.actors[actor_index]
    refresh
    self.index = 0
    self.active = false
  end
  #--------------------------------------------------------------------------
  # * Get Item
  #--------------------------------------------------------------------------
  def item
    return @data[self.index]
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    # Adds In Actor Item Cache
    @actor.item_cache.sort! {|a, b| a.id<=>b.id}
    for item in @actor.item_cache
      @data << item
    end
    # If item count is not 0, make a bit map and draw all items
    @item_max = @data.size
    if @item_max > 0
      self.contents = Bitmap.new(width - 32, row_max * 32)
      for i in 0...@item_max
        draw_item(i)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Item
  #     index : item number
  #--------------------------------------------------------------------------
  def draw_item(index)
    item, y = @data[index], index * 32
    bitmap = RPG::Cache.icon(item.icon_name)
    self.contents.blt(0, y + 4, bitmap, Rect.new(0, 0, 24, 24))
    self.contents.draw_text(32, y, 212, 32, item.name)
  end
end

#==============================================================================
# ** Scene_ActorCache
#==============================================================================

class Scene_ItemCache
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    @help_window = Window_Help.new
      @help_window.set_text('Select Item To Unassign', 1)
    @scene_objects = [@help_window]
    for i in 0..3
      eval "@actor_#{i}_heading = Window_ItemCacheHeading.new(#{i})"
      eval "@scene_objects << @actor_#{i}_heading"
      eval "@actor_#{i}_cache = Window_ItemCache.new(#{i})"
      eval "@scene_objects << @actor_#{i}_cache"
    end
    @actor_0_cache.active = true
    @actor_index = 0
    # Execute transition
    Graphics.transition
    # Main loop
    while $scene == self
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Updates Scene Objects
      @scene_objects.each {|x| x.update}
      # Frame update
      update
    end
    # Prepare for transition
    Graphics.freeze
    # Dispose Scene Objects
    @scene_objects.each {|x| x.dispose}
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # If B button is pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Switch to menu screen
      $scene = Scene_Menu.new
    end
    # If C button is pressed
    if Input.trigger?(Input::C)
      item = eval "@actor_#{@actor_index}_cache.item"
      if item.nil?
        # Plays Buzzer SE
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Plays Decision SE
      $game_system.se_play($data_system.decision_se)
      # Usassins Item
      $game_party.actors[@actor_index].unassign_item(item.id)
      # Refreshes Window
      eval "@actor_#{@actor_index}_cache.refresh"
    end
    # If Left or Right Buttons Are Pressed
    if Input.trigger?(Input::LEFT)
      # Plays Cursor SE
      $game_system.se_play($data_system.cursor_se)
      # Deativates Current Window
      eval "@actor_#{@actor_index}_cache.active = false"
      # Changes Window Index
      @actor_index == 0 ? @actor_index = 3 : @actor_index -= 1
      # Actives New Window
      eval "@actor_#{@actor_index}_cache.active = true"
    elsif Input.trigger?(Input::RIGHT)
      # Plays Cursor SE
      $game_system.se_play($data_system.cursor_se)
      # Deativates Current Window
      eval "@actor_#{@actor_index}_cache.active = false"
      # Changes Window Index
      @actor_index == 3 ? @actor_index = 0 : @actor_index += 1
      # Actives New Window
      eval "@actor_#{@actor_index}_cache.active = true"
    end
    # If A button is pressed
    if Input.trigger?(Input::A)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Switch to Item Cache screen
      $scene = Scene_Item.new
      return
    end
  end
end

#==============================================================================
# ** Scene_Item
#==============================================================================

class Scene_Item
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  alias seph_individualactorcache_sceneitem_update update
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # Updates Near's Keyboard Module
    Keyboard.update
    # Assign To Player 1
    if Keyboard.trigger?(Keyboard::Numberkeys[1])
      # If Actor is nil
      if $game_party.actors[0].nil?
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Plays Decison SE
      $game_system.se_play($data_system.decision_se)
      # Assigns Item
      $game_party.actors[0].assign_item(@item_window.item.id)
      # Refreshs Window
      @item_window.refresh
    end
    # Assign To Player 2
    if Keyboard.trigger?(Keyboard::Numberkeys[2])
      # If Actor is nil
      if $game_party.actors[1].nil?
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Plays Decison SE
      $game_system.se_play($data_system.decision_se)
      # Assigns Item
      $game_party.actors[1].assign_item(@item_window.item.id)
      # Refreshs Window
      @item_window.refresh
    end
    # Assign To Player 3
    if Keyboard.trigger?(Keyboard::Numberkeys[3])
      # If Actor is nil
      if $game_party.actors[2].nil?
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Plays Decison SE
      $game_system.se_play($data_system.decision_se)
      # Assigns Item
      $game_party.actors[2].assign_item(@item_window.item.id)
      # Refreshs Window
      @item_window.refresh
    end
    # Assign To Player 4
    if Keyboard.trigger?(Keyboard::Numberkeys[4])
      # If Actor is nil
      if $game_party.actors[3].nil?
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Plays Decison SE
      $game_system.se_play($data_system.decision_se)
      # Assigns Item
      $game_party.actors[3].assign_item(@item_window.item.id)
      # Refreshs Window
      @item_window.refresh
    end
    # If A button is pressed
    if Input.trigger?(Input::A)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Switch to item screen
      $scene = Scene_ItemCache.new
    end
    # Orginal Update Method
    seph_individualactorcache_sceneitem_update
  end
end

#--------------------------------------------------------------------------
# * End SDK Enable Test
#--------------------------------------------------------------------------
end

Instructions

Copy and Paste the code above Main.

To change from Character Sprites to Battlers, find the line:
DRAW_CHARACTER = true
and change to false

FAQ

None Yet

Compatibility

Can work with or without SDK.
Only the refresh method was re-wrote in Window_Item. Make sure no other script has this method ocupied.

Credits and Thanks

Near Fantastica for his Keyboard Module
Katzbalger for requesting this script