Is there a a function in Ruby to increment an objects variable inside an array in this example?

array << drop1.amount does not make an alias of drop1.amount, it makes a one-time copy of the number value contained in drop1.amount. When you update drop1.amount, the copy in array is unchanged. Instead, put a reference to the object onto the result array or update the result array value directly (depending on whether you want to modify the original or not).

For example we can stick to the existing design with something like:

# ...
if array.include? drop1.item
  array[array.index(drop1.item)+1] += 1
  drop1.amount += 1 # optionally update the original (less ideal than an alias)
else
  array << drop1.item
  array << drop1.amount
end
# ...
if array.include? drop2.item
  array[array.index(drop2.item)+1] += 60
  drop2.amount += 60   
else
  array << drop2.item
  array << drop2.amount
end
# ...

While this emits the expected output, this sort of awkward searching and repeated code suggests that there are fundamental design flaws.

I'd write the program something like:

Drop = Struct.new(:item, :price, :amount)

drops = [
  Drop.new("item1", 2247, 1),
  Drop.new("item2", 4401, 60)
]
increment_amounts = drops.map {|e| e.amount}
result = [nil] * drops.size

10.times do 
  choice = rand(drops.size)

  if result[choice]
    result[choice].amount += increment_amounts[choice]
  else
    result[choice] = drops[choice]
  end
end

puts result.compact
           .shuffle
           .flat_map {|e| [e.item, e.amount]}
           .to_s
           .gsub(/["\[\]]/, "")
puts "\n" + drops.map {|e| e.amount}.join("\n")

Suggestions which the above version illustrates:

• Use a struct instead of a class for such a simple type and set its properties using the constructor rather than accessors.
• Use arrays instead of thing1, thing2, etc. This makes it a lot easier to make random choices (among other things). Note that the above version is expandable if you later decide to add more drops. After adding a third or 100 drops (along with corresponding increment amounts), everything just works.
• Prefer a clear name like result instead of a generic name like array.
• x = 0 ... while x < 10 ... x += 1 is clearer as 10.times.
• Pass a regex to gsub instead of a string to avoid chaining multiple calls.

I don't know if I undestand properly the logic, but consider using a Hash instead of an Array:

h = {}
10.times do |x|
  rand1 = rand(2)

  if rand1 == 0
    if h.has_key? drop1.item
      drop1.amount += 1
      h[drop1.item] = drop1.amount
    else
      h[drop1.item] = drop1.amount
    end

  elsif rand1 == 1
    if h.has_key? drop2.item
      drop2.amount += 60
      h[drop2.item] = drop2.amount
    else
      h[drop2.item] = drop2.amount
    end
  end

end

For checking the result:

p h
p drop1.amount
p drop2.amount

class Drop
  attr_accessor :item, :price, :amount

  def initialize(item:'no_name', price: 0, amount: 0)
    @item = item
    @price = price
    @amount = amount
    @counts = 0
    @increment = amount
  end

  def count!
    @counts += 1
    @amount += @increment if @counts > 1
  end

end

Then store the instances in an array:

drops = []
drops << Drop.new(item: 'item1', price: 2247, amount: 1)
drops << Drop.new(item: 'item2', price: 4401, amount: 60)

Run the random picking sampling the drops array:

10.times do |x|
  drops.sample.count!
end

Check the result:

drops.each do |drop|
  puts "#{drop.item} - #{drop.amount} - #{drop.price}"
end

You can also define a reset method which restores the amount and the counts to the original value:

def reset
  @amount = @increment
  @count = 0
end