¡Bienvenido a Universo Maker!
¿Es esta la primera vez que visitas el foro? Si es así te recomendamos que te registres para tener completo acceso a todas las áreas y secciones del foro, así también podrás participar activamente en la comunidad. Si ya tienes una cuenta, conectate cuanto antes.
Iniciar Sesión Registrarme

No estás conectado. Conéctate o registrate

Ver el tema anterior Ver el tema siguiente Ir abajo Mensaje [Página 1 de 1.]

#1 [RPGXP] Advanced Shop System el Lun Dic 02, 2013 9:11 pm

youkai

avatar
Que poca creatividad para los nombres, no es cierto? xDDDD

De verdad que me duele entrar al foro despues de perderme por una semana y ver que no hay ni un tema nuevo :(Y mas aun ver que soy el unico user conectado T-T Asi que por eso voy a hacer todo lo que pueda para devolverle el ambiente que tenia mi casa la primera vez que entre en ella xD (Aunque tenga que pasarme una semana entera programando xP)

Y bueno, he aqui el primer resultado de mi decepcion...


  • Titulo: Advanced Shop System
  • Autor: youkai
  • Version: 1.1
  • Fecha: 8/12/2013

El modo de uso viene dentro del mismo script(bastante trabajo me tomo explicar como funciona todo lo que hice XDDD)

Imagenes no pongo ya que lamentablemente no hice ninguna modificacion notable en el aspecto visual de la tienda...tengo que anotar eso tambien como tarea para la proxima version del script xP

Script:
Código:
# **/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\
#                          ADVANCED SHOP SYSTEM
#        Autor: youkai
#        Version: 1.1
#        Fecha: 8/12/2013
# **/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\
=begin
  Notas del autor:
Este fue un script que me tomo al menos una semana de programacion. Su contenido
puede que resulte un poco complicado de usar ya que hay que estar bien claros
con las matematicas para no pifiar y hacer que los jugadores se hagan millonarios
solo llevando pociones de una tienda a otra XD Sin mucho mas que decir, paso a
explicar el funcionamiento del mismo.
En esta version aun no he implementado el sistema para combinar entre las tiendas
que siempre hemos llamado por los codigos del maker y este estilo. Para una proxi-
ma version me encargare de ello.
# **/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\
  Change log:
 
Version 1.1:
  * Corregidos algunos bugs
    - Al vender por cantidad habia un error en la formula
    - Al reabastecer las tiendas se crasheaba el script.
  * Optimizado el codigo
 
Version 1.0
  * Codigo base del script, su primera version.
   
# **/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\**/**\
  Modo de uso:
 El unico modulo creado para que el usuario modifique es Shop_Base asi que a menos
que sepan lo que hacen, no vayan mucho mas alla.

# *=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=
 * Como configuro la tienda
Yo por defecto cree 2 tiendas(las mismas que usaba para probar xD) La configuracion
de los objetos, asi como la cantidad promedio de los mismos que tendra la tienda
se hace en Shop_Goods de la siguiente forma:
  (Todo lo que esta entre comillas[""] significa que no se modifica)
 
    "Shop_Goods = {"
    ID de la tienda "=> [" Objeto1, Objeto2, ... "],"
    ...
    "}"
   
# *=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=
 * Como configuro los objetos
    [tipo de objeto, ID del objeto, cantidad inicial, cantidad promedio]
 
  tipo de objeto: Esto es para diferenciar entre Items, Weapons y Armors. Como quiza
  sepan estos 3 tipos de objetos van por separados y los ID's de cada uno de ellos
  va de 1 a ... Asi que es necesaria una forma de diferenciarlos.
 
  Para decir que es un item poner: 0
  Para decir que es un arma poner: 1
  Para que sea una armadura poner: 2
 
  ID del objeto: El ID que posee dicho item/arma/armadura en la Base de Datos
 
  cantidad inicial: La cantidad con la que empezara la tienda de dicho objeto
 
  cantidad promedio: Esta es la cantidad que digamos marcara el limite de exigen-
  cia de la tienda. O sea, si la misma posee mas items que esta cantidad los pre-
  cios seran menores al (precio configurado en la Base de datos * el tax de la tienda)
 
NOTA: Si no se configura una cantidad promedio el item se tratara como un item
temporal, el cual puede desaparecen en cualquier momento que se refresquen los
suministros de la tienda. Este es el caso de los items que le vendemos a la tienda,
los cuales por defecto toman a 99 la cantidad promedio.

# *=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=
 * Como configuro el tax
El tax digamos que es el impuesto que pone la tienda sobre el precio estandar(el
definido en la Base de Datos) del objeto. Para mejor comprension de esto dejo la
formula: (precio * tax)
Entonces, para configurarlo es en Shop_Tax y de la siguiente forma:

  "Shop_Tax = {"
  ID de la tienda "=>" tax ","
  ...
  "}"
 
# *=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=
 * Como configurar el flujo del precio
El flujo del precio es la variacion que tendra dicho objeto en su precio(xD) a
medida que el mismo se vaya acabando/repletando. En resumen, lo que hace es que
entre menos producto, mayor precio; y entre mas producto, menos vale.
Para este calculo se usa la cantidad promedio que especifiques en la configuracion
del objeto. El objeto tendra su precio real(modificado por el tax) cuando la canti-
dad en posesion del mismo por la tienda sea igual o muy cerca de la cantidad
promedio.
Para configurarlo es en Shop_PriceFlow de la siguiente forma:

  "Shop_PriceFlow = {"
  ID de la tienda "=>" flujo del precio ","
  ...
  "}"

NOTA: Han de tener el cuenta que con un flujo igual a 1.0 duplicaria el precio del
objeto cuando solo quede un ejemplar en la tienda y en caso de que la cantidad que
posea la tienda sea el doble a la cantidad promedio el precio reduciria al doble de
su precio original, asi que por favor tengan todo esto en cuenta.

# *=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=
 * Forma de llamar la tienda
Para eso debemos agregar en un comando Llamar Script:

  start_shop(ID de la tienda)

El ID de la tienda va en correspondencia con el ID que le das a la tienda en la
configuracion.

# *=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=
  * Forma de reabastecer la/s tienda/s
Para eso debemos agregar en un comando Llamar Script:

  reset_shop{([ID's de las tiendas])}
 
Lo que señalo entre llaves significa que es opcional. O sea, bien podemos poner
solo reset_shop y el script reabastecera todas las tiendas pero si solo queremos
que, por ejemplo, solo lo haga con la tienda 3 entonces ponemos:

  reset_shop([3])
 
Y si quieremos que sea con las tiendas 1, 2 y 3 solamente, pues:

  reset_shop([1, 2, 3])

Este "reabastecimiento" es relativo ya que el script lo que hace es sumarle o
restarle cantidad al azar a los items que posea la tienda. Los items predefinidos
para la tienda nunca se perderan de ella mientras que los que les vendamos tienen
una posibilidad de 3 en 10 de desaparecer. Recuerden que si en el calculo de la
cantidad se produce una resta y la cantidad del item llega a 0, este no se mostra-
ra, no importa si es predefinido o no.

# *=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=
=end
# -------------- Eso es todo, los dejo con las configuraciones --------------- #

module Shop_Base
  Shop_Goods = {
  1 => [[0, 1, 56, 70], [0, 2, 34, 81]],
  2 => [[0, 1, 60, 60], [0, 5, 62, 80], [0, 2, 34, 34], [2, 1, 20, 40], [1, 2, 34, 60]],
  }
  Shop_Tax = {
  1 => 1.3,
  2 => 1.0,
  }
 
  Shop_PriceFlow = {
  1 => 1.5,
  2 => 1.0,
  }
  def self.make_data
    $data_shops = []
    Shop_Goods.each_key{|i|
    $data_shops[i] = RPG::Shop.new
    $data_shops[i].items = Shop_Goods[i]
    $data_shops[i].tax = Shop_Tax[i]
    $data_shops[i].price_flow = Shop_PriceFlow[i]
    $data_shops[i].items.sort!
    }
  end
end

module RPG
  class Item
    def type
      0
    end
  end
 
  class Weapon
    def type
      1
    end
  end
 
  class Armor
    def type
      2
    end
  end
end


class Game_Temp
  attr_accessor :shop_id
  alias shop_system_temp_initialize initialize
  def initialize
    shop_system_temp_initialize
    @shop_id = nil
  end
end

module RPG
  class Shop
    attr_accessor :items
    attr_accessor :price_flow
    attr_accessor :tax
    def initialize
      @items = []
      @price_flow = 1.0
      @tax = 1.0
    end
  end
end

#==============================================================================
# ** Window_ShopBuy
#------------------------------------------------------------------------------
#  This window displays buyable goods on the shop screen.
#==============================================================================

class Window_ShopBuy < Window_Selectable
  attr_accessor :data
  #--------------------------------------------------------------------------
  # * Object Initialization
  #    shop_goods : goods
  #--------------------------------------------------------------------------
  def initialize(shop_goods, shop_id)
    super(0, 128, 368, 352)
    @shop_goods = shop_goods
    @shop_id = shop_id
    refresh
    self.index = 0
  end
  #--------------------------------------------------------------------------
  # * Item Acquisition
  #--------------------------------------------------------------------------
  def item
    return @data[self.index].nil? ? nil : @data[self.index][0]
  end
 
  def amount
    return @data[self.index][1]
  end
 
  def amount=(val)
    @data[self.index][1] = val
    $data_shops[@shop_id].items[self.index][2] = val
    item = $data_shops[@shop_id].items[self.index]
    if item[2] == 0
      $data_shops[@shop_id].items.delete(item)
      $data_shops[@shop_id].items.push(item)
    end
  end
 
  def prom(index = self.index)
    return $data_shops[@shop_id].items[index][3] ?
    $data_shops[@shop_id].items[index][3].to_f : 99.0
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    for goods_item in @shop_goods
      next if goods_item[2] == 0
      case goods_item[0]
      when 0
        item = [$data_items[goods_item[1]], goods_item[2]]
      when 1
        item = [$data_weapons[goods_item[1]], goods_item[2]]
      when 2
        item = [$data_armors[goods_item[1]], goods_item[2]]
      end
      if item[0] != nil
        @data.push(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
  #--------------------------------------------------------------------------
  # * Draw Item
  #    index : item number
  #--------------------------------------------------------------------------
  def draw_item(index)
    item = @data[index][0]
    amount = @data[index][1]
    # Get items in possession
    case item
    when RPG::Item
      number = $game_party.item_number(item.id)
    when RPG::Weapon
      number = $game_party.weapon_number(item.id)
    when RPG::Armor
      number = $game_party.armor_number(item.id)
    end
    # If price is less than money in possession, and amount in possession is
    # not 99, then set to normal text color. Otherwise set to disabled color
    price = (item.price * $data_shops[@shop_id].tax) - ((item.price * $data_shops[@shop_id].tax) * ((amount - 1) /
    (prom(index) / $data_shops[@shop_id].price_flow) - $data_shops[@shop_id].price_flow)).ceil
    if price <= $game_party.gold and number < 99
      self.contents.font.color = normal_color
    else
      self.contents.font.color = disabled_color
    end
    x = 4
    y = index * 32
    rect = Rect.new(x, y, self.width - 32, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    bitmap = RPG::Cache.icon(item.icon_name)
    opacity = self.contents.font.color == normal_color ? 255 : 128
    self.contents.blt(x + 32, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
    self.contents.draw_text(x, y, 48, 32, amount.nil? ? "99" : amount.to_s, 0)
    self.contents.draw_text(x + 62, y, 212, 32, item.name, 0)
    self.contents.draw_text(x + 240, y, 88, 32, price.to_i.to_s, 2)
  end
end

#==============================================================================
# ** Window_ShopNumber
#------------------------------------------------------------------------------
#  This window is for inputting quantity of items to buy or sell on the
#  shop screen.
#==============================================================================

class Window_ShopNumber < Window_Base
  #--------------------------------------------------------------------------
  # * Set Items, Max Quantity, and Price
  #--------------------------------------------------------------------------
  def set(item, max, price, phase, *fMembers)
    @item = item
    @max = max
    @price = price
    @phase = phase
    @members = fMembers
    @number = 1
    refresh
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    draw_item_name(@item, 4, 96)
    self.contents.font.color = normal_color
    self.contents.draw_text(272, 96, 32, 32, "×")
    self.contents.draw_text(308, 96, 24, 32, @number.to_s, 2)
    self.cursor_rect.set(304, 96, 32, 32)
    # Draw total price and currency units
    domination = $data_system.words.gold
    cx = contents.text_size(domination).width
    self.contents.font.color = normal_color
    self.contents.draw_text(4, 160, 328-cx-2, 32, total_price.to_s, 2)
    self.contents.font.color = system_color
    self.contents.draw_text(332-cx, 160, cx, 32, domination, 2)
  end
 
  def total_price
    total_price = 0
    case @phase
    when 0
      @number.times{|i|
      total_price += @price - (@price * ((@members[0] - i.succ) / (@members[2] / @members[1]) - @members[1])).ceil}
    when 1
      @number.times{|i|
      total_price += @price - (@price / ((@members[0] - i.succ) / (@members[2] / @members[1]) - @members[1])).ceil}     
    end
    return total_price
  end
end

#==============================================================================
# ** Scene_Title
#------------------------------------------------------------------------------
#  This class performs title screen processing.
#==============================================================================

class Scene_Title
  alias advanced_shop_command_new_game command_new_game
  #--------------------------------------------------------------------------
  # * Command: New Game
  #--------------------------------------------------------------------------
  def command_new_game
    Shop_Base.make_data
    advanced_shop_command_new_game
  end
end

#==============================================================================
# ** Scene_Map
#------------------------------------------------------------------------------
#  This class performs map screen processing.
#==============================================================================

class Scene_Map
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # Loop
    loop do
      # Update map, interpreter, and player order
      # (this update order is important for when conditions are fulfilled
      # to run any event, and the player isn't provided the opportunity to
      # move in an instant)
      $game_map.update
      $game_system.map_interpreter.update
      $game_player.update
      # Update system (timer), screen
      $game_system.update
      $game_screen.update
      # Abort loop if player isn't place moving
      unless $game_temp.player_transferring
        break
      end
      # Run place move
      transfer_player
      # Abort loop if transition processing
      if $game_temp.transition_processing
        break
      end
    end
    # Update sprite set
    @spriteset.update
    # Update message window
    @message_window.update
    # If game over
    if $game_temp.gameover
      # Switch to game over screen
      $scene = Scene_Gameover.new
      return
    end
    # If returning to title screen
    if $game_temp.to_title
      # Change to title screen
      $scene = Scene_Title.new
      return
    end
    # If transition processing
    if $game_temp.transition_processing
      # Clear transition processing flag
      $game_temp.transition_processing = false
      # Execute transition
      if $game_temp.transition_name == ""
        Graphics.transition(20)
      else
        Graphics.transition(40, "Graphics/Transitions/" +
          $game_temp.transition_name)
      end
    end
    # If showing message window
    if $game_temp.message_window_showing
      return
    end
    # If encounter list isn't empty, and encounter count is 0
    if $game_player.encounter_count == 0 and $game_map.encounter_list != []
      # If event is running or encounter is not forbidden
      unless $game_system.map_interpreter.running? or
            $game_system.encounter_disabled
        # Confirm troop
        n = rand($game_map.encounter_list.size)
        troop_id = $game_map.encounter_list[n]
        # If troop is valid
        if $data_troops[troop_id] != nil
          # Set battle calling flag
          $game_temp.battle_calling = true
          $game_temp.battle_troop_id = troop_id
          $game_temp.battle_can_escape = true
          $game_temp.battle_can_lose = false
          $game_temp.battle_proc = nil
        end
      end
    end
    # If B button was pressed
    if Input.trigger?(Input::B)
      # If event is running, or menu is not forbidden
      unless $game_system.map_interpreter.running? or
            $game_system.menu_disabled
        # Set menu calling flag or beep flag
        $game_temp.menu_calling = true
        $game_temp.menu_beep = true
      end
    end
    # If debug mode is ON and F9 key was pressed
    if $DEBUG and Input.press?(Input::F9)
      # Set debug calling flag
      $game_temp.debug_calling = true
    end
    # If player is not moving
    unless $game_player.moving?
      # Run calling of each screen
      if $game_temp.battle_calling
        call_battle
      elsif $game_temp.shop_calling || $game_temp.shop_id
        call_shop
      elsif $game_temp.name_calling
        call_name
      elsif $game_temp.menu_calling
        call_menu
      elsif $game_temp.save_calling
        call_save
      elsif $game_temp.debug_calling
        call_debug
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Shop Call
  #--------------------------------------------------------------------------
  def call_shop
    if $game_temp.shop_calling
      # Clear shop call flag
      $game_temp.shop_calling = false
      # Straighten player position
      $game_player.straighten
      # Switch to shop screen
      $scene = Scene_Shop.new
    elsif $game_temp.shop_id
      $game_temp.shop_goods = $data_shops[$game_temp.shop_id].items
      # Straighten player position
      $game_player.straighten
      # Switch to shop screen
      $scene = Scene_Shop.new($game_temp.shop_id)
      # Clear shop id
      $game_temp.shop_id = nil
    end
  end
end

#==============================================================================
# ** Scene_Save
#------------------------------------------------------------------------------
#  This class performs save screen processing.
#==============================================================================
class Scene_Save
  alias shop_system_write_save_data write_save_data
  def write_save_data(file)
    Marshall.dump($data_shops, file)
    shop_system_write_save_data(file)
  end
end

#==============================================================================
# ** Scene_Load
#------------------------------------------------------------------------------
#  This class performs load screen processing.
#==============================================================================
class Scene_Load
  alias shop_system_read_save_data read_save_data
  def read_save_data(file)
    $data_shops = Marshall.load(file)
    shop_system_read_save_data(file)
  end
end

#==============================================================================
# ** Scene_Shop
#------------------------------------------------------------------------------
#  This class performs shop screen processing.
#==============================================================================

class Scene_Shop
  def initialize(shop_id = nil)
    @shop_id = shop_id
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    # Make help window
    @help_window = Window_Help.new
    # Make command window
    @command_window = Window_ShopCommand.new
    # Make gold window
    @gold_window = Window_Gold.new
    @gold_window.x = 480
    @gold_window.y = 64
    # Make dummy window
    @dummy_window = Window_Base.new(0, 128, 640, 352)
    # Make buy window
    @buy_window = Window_ShopBuy.new($game_temp.shop_goods, @shop_id)
    @buy_window.active = false
    @buy_window.visible = false
    @buy_window.help_window = @help_window
    # Make sell window
    @sell_window = Window_ShopSell.new
    @sell_window.active = false
    @sell_window.visible = false
    @sell_window.help_window = @help_window
    # Make quantity input window
    @number_window = Window_ShopNumber.new
    @number_window.active = false
    @number_window.visible = false
    # Make status window
    @status_window = Window_ShopStatus.new
    @status_window.visible = false
    # 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
    # Dispose of windows
    @help_window.dispose
    @command_window.dispose
    @gold_window.dispose
    @dummy_window.dispose
    @buy_window.dispose
    @sell_window.dispose
    @number_window.dispose
    @status_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when buy window is active)
  #--------------------------------------------------------------------------
  def update_buy
    # Set status window item
    @status_window.item = @buy_window.item
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Change windows to initial mode
      @command_window.active = true
      @dummy_window.visible = true
      @buy_window.active = false
      @buy_window.visible = false
      @status_window.visible = false
      @status_window.item = nil
      # Erase help text
      @help_window.set_text("")
      return
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      if @buy_window.item.nil?
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Get item
      @item = @buy_window.item
      price = @item.price * $data_shops[@shop_id].tax
      # If item is invalid, or price is higher than money possessed
      if @item == nil or price - (price * ((@buy_window.amount - 1) /
      (@buy_window.prom / $data_shops[@shop_id].price_flow) - $data_shops[@shop_id].price_flow)).ceil > $game_party.gold
        # Play buzzer SE
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Get items in possession count
      case @item
      when RPG::Item
        number = $game_party.item_number(@item.id)
      when RPG::Weapon
        number = $game_party.weapon_number(@item.id)
      when RPG::Armor
        number = $game_party.armor_number(@item.id)
      end
      # If 99 items are already in possession
      if number == 99
        # Play buzzer SE
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Play decision SE
      $game_system.se_play($data_system.decision_se)
      # Calculate maximum amount possible to buy
      if @item.price == 0       
        max = 99
      else
        val = 0
        @buy_window.amount.times{|i|
        val += price - (price * ((@buy_window.amount - i.succ) /
        (@buy_window.prom / $data_shops[@shop_id].price_flow) - $data_shops[@shop_id].price_flow)).ceil
        if val >= $game_party.gold || i.succ == @buy_window.amount
          max = i.succ == @buy_window.amount || val == $game_party.gold ? i.succ : i
          break
        end}       
      end
      max = [max, 99 - number].min
      max = [max, @buy_window.amount].min
      # Change windows to quantity input mode
      @buy_window.active = false
      @buy_window.visible = false
      @number_window.set(@item, max, (@item.price * $data_shops[@shop_id].tax).to_i, 0,
      @buy_window.amount, $data_shops[@shop_id].price_flow, @buy_window.prom)
      @number_window.active = true
      @number_window.visible = true
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when sell window is active)
  #--------------------------------------------------------------------------
  def update_sell
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Change windows to initial mode
      @command_window.active = true
      @dummy_window.visible = true
      @sell_window.active = false
      @sell_window.visible = false
      @status_window.item = nil
      # Erase help text
      @help_window.set_text("")
      return
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      # Get item, set status window item
      @item = @status_window.item = @sell_window.item
      # If item is invalid, or item price is 0 (unable to sell)
      if @item == nil or @item.price == 0
        # Play buzzer SE
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Play decision SE
      $game_system.se_play($data_system.decision_se)
      # Get items in possession count
      number = 0
      $data_shops[@shop_id].items.each{|item|
      if item[0, 2] == [@item.type, @item.id]
        number = item[2]
        break
      end}
      # Maximum quanitity to sell = number of items in possession
      case @item
      when RPG::Item
        max = $game_party.item_number(@item.id)
      when RPG::Weapon
        max = $game_party.weapon_number(@item.id)
      when RPG::Armor
        max = $game_party.armor_number(@item.id)
      end
      # Change windows to quantity input mode
      @sell_window.active = false
      @sell_window.visible = false
      @number_window.set(@item, max, (@item.price * $data_shops[@shop_id].tax).to_i / 2, 1,
      number, $data_shops[@shop_id].price_flow, @buy_window.prom)
      @number_window.active = true
      @number_window.visible = true
      @status_window.visible = true
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when quantity input window is active)
  #--------------------------------------------------------------------------
  def update_number
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Set quantity input window to inactive / invisible
      @number_window.active = false
      @number_window.visible = false
      # Branch by command window cursor position
      case @command_window.index
      when 0  # buy
        # Change windows to buy mode
        @buy_window.active = true
        @buy_window.visible = true
      when 1  # sell
        # Change windows to sell mode
        @sell_window.active = true
        @sell_window.visible = true
        @status_window.visible = false
      end
      return
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      # Play shop SE
      $game_system.se_play($data_system.shop_se)
      # Set quantity input window to inactive / invisible
      @number_window.active = false
      @number_window.visible = false
      # Branch by command window cursor position
      case @command_window.index
      when 0  # buy
        # Buy process
        $game_party.lose_gold(@number_window.total_price.to_i)
        @buy_window.amount -= @number_window.number
        case @item
        when RPG::Item
          $game_party.gain_item(@item.id, @number_window.number)
        when RPG::Weapon
          $game_party.gain_weapon(@item.id, @number_window.number)
        when RPG::Armor
          $game_party.gain_armor(@item.id, @number_window.number)
        end
        @buy_window.index -= 1 if @buy_window.amount == 0 && @buy_window.data.size - 1 == @buy_window.index &&
        @buy_window.index > 0
        # Refresh each window
        @gold_window.refresh
        @buy_window.refresh
        @status_window.refresh
        # Change windows to buy mode
        @buy_window.active = true
        @buy_window.visible = true
      when 1  # sell
        # Sell process
        result = false
        $data_shops[@shop_id].items.each{|item|
        if item[0, 2] == [@item.type, @item.id]
          item[2] += @number_window.number
          result = true
          break
        end}
        $game_party.gain_gold(@number_window.total_price.to_i)
        unless result
          $data_shops[@shop_id].items.push([@item.type, @item.id, @number_window.number])
        end
        $data_shops[@shop_id].items.sort!
        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
        # Refresh each window
        @gold_window.refresh
        @sell_window.refresh
        @status_window.refresh
        # Change windows to sell mode
        @sell_window.active = true
        @sell_window.visible = true
        @status_window.visible = false
      end
    end
  end
end

class Interpreter
  def reset_shop(id = [])
    if id.empty?
      $data_shops.each_index{|shop_id|
      next if $data_shops[shop_id].nil?
      $data_shops[shop_id].items.each{|item|
      if item[3] != nil
        item[2] = item[3] + rand(30) - 15
      else
        if rand(10) > 6
          $data_shops[shop_id].items.delete(item)
          next
        end
        item[2] += rand(30) - 15
      end
      item[2] = item[2] > 99 ? 99 : item[2] < 0 ? 0 : item[2]
      $data_shops[shop_id].items.sort!}}
    else
      id.each{|shop_id|
      next if $data_shops[shop_id].nil?
      $data_shops[shop_id].items.each{|item|
      if item[3] != nil
        item[2] = item[3] + rand(20) - 40
      else
        if rand(10) > 6
          $data_shops[shop_id].items.delete(item)
          next
        end
        item[2] += rand(30) - 15
      end
      item[2] = item[2] > 99 ? 99 : item[2] < 0 ? 0 : item[2]
      $data_shops[shop_id].items.sort!}}
    end
  end
 
  def start_shop(id)
    $game_temp.shop_id = id
  end 
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # Initialize loop count
    @loop_count = 0
    # Loop
    loop do
      # Add 1 to loop count
      @loop_count += 1
      # If 100 event commands ran
      if @loop_count > 100
        # Call Graphics.update for freeze prevention
        Graphics.update
        @loop_count = 0
      end
      # If map is different than event startup time
      if $game_map.map_id != @map_id
        # Change event ID to 0
        @event_id = 0
      end
      # If a child interpreter exists
      if @child_interpreter != nil
        # Update child interpreter
        @child_interpreter.update
        # If child interpreter is finished running
        unless @child_interpreter.running?
          # Delete child interpreter
          @child_interpreter = nil
        end
        # If child interpreter still exists
        if @child_interpreter != nil
          return
        end
      end
      # If waiting for message to end
      if @message_waiting
        return
      end
      # If waiting for move to end
      if @move_route_waiting
        # If player is forcing move route
        if $game_player.move_route_forcing
          return
        end
        # Loop (map events)
        for event in $game_map.events.values
          # If this event is forcing move route
          if event.move_route_forcing
            return
          end
        end
        # Clear move end waiting flag
        @move_route_waiting = false
      end
      # If waiting for button input
      if @button_input_variable_id > 0
        # Run button input processing
        input_button
        return
      end
      # If waiting
      if @wait_count > 0
        # Decrease wait count
        @wait_count -= 1
        return
      end
      # If an action forcing battler exists
      if $game_temp.forcing_battler != nil
        return
      end
      # If a call flag is set for each type of screen
      if $game_temp.battle_calling or
        $game_temp.shop_calling or
        $game_temp.name_calling or
        $game_temp.menu_calling or
        $game_temp.save_calling or
        $game_temp.gameover or
        $game_temp.shop_id
        return
      end
      # If list of event commands is empty
      if @list == nil
        # If main map event
        if @main
          # Set up starting event
          setup_starting_event
        end
        # If nothing was set up
        if @list == nil
          return
        end
      end
      # If return value is false when trying to execute event command
      if execute_command == false
        return
      end
      # Advance index
      @index += 1
    end
  end
end
Como siempre digo: "Enjoy it, guys!" xD Si tienen opiniones, nuevas ideas, posibles cambios, bugs que reportar, asdfs; me comentan aqui o me envian un MP.

Actualizado a la version 1.1
Cambios:
  • Corregidos algunos bugs
    - Al vender por cantidad habia un error en la formula
    - Al reabastecer las tiendas se crasheaba el script.
  • Optimizado el codigo


Saludos,
¥oukai



Última edición por youkai el Dom Dic 08, 2013 9:58 pm, editado 1 vez

#2 Re: [RPGXP] Advanced Shop System el Mar Dic 03, 2013 4:47 am

Cuervoso

avatar
Yo siempre me paso por aquí, aunque sea como invitado par ver qué hay de nuevo. Aunque realmente no ha habido mucho xD.

En cuanto al Script, me gustó la mecánica de éste, me pareció genial que la "oferta y demanda" y los impuestos afecten a los productos de las tiendas, ya que estas variables son las que realmente afectan a los precios en la vida real xD.

+3 Makedas.

Por cierto, realmente valoro tu iniciativa y el cariño que le tienes al foro, pensaba que era el único que continuaba pasando por aquí, y eso que no soy el único miembro del Staff. Por mi parte, veré que puedo hacer para dar a la gente algo que comentar.

Como nunca digo: "You did a really great job, mate! If you make a Vx Ace version of your script, I surely will use it in my game someday" xD.

Saludos.






Cuervoso! No te pases ¬_¬

#3 Re: [RPGXP] Advanced Shop System el Mar Dic 03, 2013 6:59 am

youkai

avatar
Ok bro, I will think in your request. Now this forum seems more like chaosproyect, with people speaking inglisssh xDDD
Hare la adaptacion para Ace...despues de todo lo mas complicado de este script no fue tanto la programacion sino como las formulas. Pienso que no deba tomarme mucho tiempo la adaptacion xD
Saludos,
¥oukai

#4 Re: [RPGXP] Advanced Shop System el Dom Dic 08, 2013 5:39 am

orochii

avatar
dis's good screepp, oelle dhon. U r rly 1337 dood!

Boot y no screan?
Horo horo horo (?)

===
Lo pruebo cuando actualices aquellos bugs xD... antes probé el de Ace, pero tengo que reprobarlo (del verbo volver a probar xD), porque lo intenté usar en uno de mis salvajes proyectos de pruebas x'D (no sé porqué no me aparecían los objetos de la tienda :'D).
Una pregunta además, ¿hay algo así como un .refresh? Es que ví que mencionabas algo así, y quiza era eso lo que me faltó llamar al estar probando el del Ace.

No más preguntas por el momento, salut,
Orochii Zouveleki

PD.: Screeeeeeeeeeeeeeeenssssss :V. ...bueno quiza no sean muy ilustrativas... asdf.

#5 Re: [RPGXP] Advanced Shop System el Dom Dic 08, 2013 10:08 pm

youkai

avatar
Pues orochi-in(?) ya estan corregidos esos malevolos bugs en esta version del script. Los cambios que hice estan en el change log(increible...hice un change log XDDD)
Lo de la tienda seguramente te sucedio porque cambie la forma de llamado para el Ace y se me olvido cambiar las cosas en las explicaciones xD Lo del refresh(que en si es reset_shop xD) es para abastecer la tienda sino podras imaginar el resultado xD (-faq se acabaron las pociones en mi juego- xD)
Ya arregle todo asi que ahora no debes de tener mas problemas con el tema Ópalo Guiño
Saludos,
¥oukai

Contenido patrocinado


Ver el tema anterior Ver el tema siguiente Volver arriba  Mensaje [Página 1 de 1.]

Permisos de este foro:
No puedes responder a temas en este foro.