¡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 [RPG Maker XP] Script: Mini juego de cocina. el Lun Dic 12, 2011 12:39 am

~thekiller

avatar
¡Hola usuarios de Universo Maker! Este aporte de script es a peticion de un usuario.

Script: Mini juego de cocina.
Autor: momomomo
Versión: ???

Sistema de cocina con:
-Nivel de maestria para cada personaje o para grupo.
-Resultado o fallo en la creacion de la comida.
-Ingredientes adicionales dependiendo del personaje.
-Uso de Interruptores para activar recetas para cocinar.
-Creacion de alimentos para uso inmediato... no crea un item, solo toma sus propiedades para usarse luego de su creacion.

Screens:
Spoiler:


Script:
Código:
# Sistema de Alimentación
#
#Cada vez mayor, y muchos puntos de ajuste (el sudor)
# Trate de escribir un mínimo de trabajo para hacer de todos modos.
#
# Por favor introduzca los ajustes básicos en la primera.
module Cooking_System_Config

  COOK_BATTLE_COUNT = 0      # El tiempo de cocción hasta que la próxima batalla (0 sin límite)
  COOK_TYPE_SELECT = 1        # Cocina, seleccionar a una persona para cocinar por 1 a 0 no hay selección
  USE_COOK_MASTERY = true    # Si se utiliza la característica habilidad para cocinar
  MAX_COOK_MASTERY = 5        # Máximo grado de habilidad
  COOK_SUCCESS_REVISE = 5    # La tasa de éxito de la remuneración por competencia plato
  USE_COOK_MATE_ADD = true    # Ya sea que utilice la función para añadir los ingredientes
  USE_ACTOR_MATE_ADD = true  # Si los ingredientes adicionales se establecen para cada actor
  ADD_MATE_SHOW = true        # Agregar los ingredientes para demostrar si
 
end
#Si se deja un lugar tan difícil de entender los complementos,
# Segundo de la parte superior COOK_TYPE_SELECT
# 1 Al seleccionar los miembros del partido que de vez en cocinar los alimentos.
# Cuando se ajusta a 0, en lugar de alguien que no elige la hora de cocinar los alimentos por todas las partes.
#
#USE_COOK_MASTERY tercio de la parte superior
# Si se define como verdadera comida, y varios
# Ahora aumenta la cantidad de tiempo de recuperación que hizo el plato.
# Cuando falsa, usted pierde la capacidad de la habilidad en cuestión.
#
#A partir de la quinta parte más COOK_SUCCESS_REVISE
# Aumentar la tasa de éxito es la habilidad de un tiempo de cocción.
# (Exp) x (el aumento) se añadirá a la base de cocinar tasa de éxito.
#
#
#
#Una vez que hayas configurado, vaya a la configuración de la base de datos de una vez.
# En este sistema los alimentos, la comida es, por supuesto, también se establece en hacer que los alimentos
# Establezca la entrada del elemento en la base de datos.
# Por el momento, por favor, que el nombre de los alimentos, según corresponda.
# El nombre, la descripción y cantidad de la recuperación HPSP, iconos, cambiar el estado, tal como se refleja.
# Use tan poco diferentes,
#
#Exactitud de la tasa de éxito de los alimentos de base.
#Artículo # SE cuando se usa durante fuegos ... SE
#ID Common Event ID # evento común ... cuando usted comience a cocinar
# F ... la defensa física de cocina dificultad (el valor de las competencias básicas - Después de la cocción hasta el momento)
# F ... Defensa Mágica habilidad de recuperación de la corrección de valor (aumentar la cantidad de la recuperación por #habilidad)
#
# No.
#
# Por cierto, si usted no tiene intención de utilizar la habilidad,
# Habilidad Partidas relacionadas no está obligado a establecer.
#
# Más tarde, cuando la comida no "Cocinar Failed" Por favor, seguir haciendo una.
# Se utiliza para cocinar el fracaso.
#
#
#
#Justo por debajo de la set_cookid siguiente.
# Establezca el ID de la comida en la base de datos antes
#Bajo el # @ cookidset [1] = 51
#Esta parte # ↑
#Por favor, pon #.
# Se mostrará en esta comida para pantalla de la lista.
#
#
#
#Las siguientes recetas se establezcan.
# Hay un poco menos de set_cook_recipe set_cookid.
#
#Pero la receta de configuración
#
#1. Tipo de alimentación directamente a la ID de elemento
# @ Receta [1] = {41 => 1, 43 => 1}
#Al igual que # {elemento = {ID parte de}>} El número requerido
#Por favor, introduzca # y.
#
#2. Especificado en la clasificación
#Receta # @ [2] = {"arroz tipo '=> 1, el sistema de" pegamento "=> 2}
#Al igual que # {a} {parte del nombre de "Category" =>} El número requerido
#Por favor, introduzca # y.
# La clasificación es para cubrir todos los elementos con los atributos de nombre de la categoría.
# Cuando usted consume el alimento se consume de forma aleatoria de entre ellos.
#
#Además,
#Receta # @ [3] = {"Sistema de vegetales" => 2, 41 => 1}
# Como también se puede utilizar directamente con la clasificación dada al mismo tiempo.
#
#
#
#La entrega de alimentos fracaso.
# Establecer el set_fail_food_id.
#Básicamente #
# @ Fail_food_id [0] = 50 # valores por defecto
# ¿Debo poner el ID del tema de la comida Crelle había hecho falta antes del número correcto.
#
#@ Fail_food_id [1] = 49
#Toka # hacerlo, se puede establecer el plato de cada plato no.
#
#
#
#Pasado.
# Yappari, se encuentra justo debajo de la set_visible_Switche antes.
# Este es el número del juego de cambiar la configuración para determinar si la presentación de los alimentos.
#
# @ Visible_Switche [3] = 20
#
# El juego cambia a un número adecuado de este número.
# En el ejemplo anterior, los alimentos se muestra en el interruptor de juego de mesa tercero 20 está en ON
# Tiene que aparecer.
#
#
# Configuración básica se ha terminado.
#
#
#
# Corrección individual ○ actor dificultad para cocinar
# Esta es la fuerza que puede Yaranaku,
# Si se ha configurado para permitir a cada actor para cocinar, es posible que desee establecer.
# En lugar de, sino que cada actor puede cocinar muchos problemas
#Todo el mundo es # el mismo rendimiento, pero es totalmente sin sentido (sudor)
#Si la configuración de # en todos los alimentos del partido es muy alto.
# Si se establece ningún significado.
#
#• Determinar el #
##------------------------------------------------ --------------------------
# # Establecer la dificultad de compensación ● actor
##------------------------------------------------ --------------------------
# Def set_actor_cook_difficulty
#Aquí es # ↑. Justo debajo de la Sakki.
#
# Establezca el valor, la cocina de dificultad (el valor de las competencias básicas - Después de la cocción de un número de #veces) se añadirá a.
# También puede especificar negativo.
#
# 1 # Cuando Musubi
# @ Actor_cook_difficulty [1] = 0 # Arushesu
# @ Actor_cook_difficulty [2] = 1 # Basilio
# @ Actor_cook_difficulty [7] = 0 # Gloria
# @ Actor_cook_difficulty [8] = 2 # Hilda
#
# Sé que usted está viendo Moraere [] Los números de identificación en el actor
# Número correcto es el valor que se agrega a los alimentos difíciles.
#
#
# ○ Información adicional acerca de los alimentos
# Agregar los ingredientes son cosas como el relleno llamado.
# Si conoce la cierta "resonancia RPG con usted," Por favor, imaginar el rough.
# Que digo, o referencia a la misma matriz y este sistema de antena (el sudor)
# Incluso si usted tiene comida que usted puede agregar los ingredientes.
# Si se utiliza, el efecto del suplemento añadido a los efectos de los ingredientes alimentarios.
# La configuración se realiza en set_add_mate.
# Puede establecer los ingredientes se suman a un nivel de habilidad máxima de hasta + 1,
# Me gustaría consumir los alimentos sin ninguna pregunta, si se establece demasiado
# Puede ser difícil de usar en la cocina, y viceversa.
#
# Corrección de errores 08/29/2005
# Fija una posible denegación de alimentos en la batalla.
# Cuando la recuperación de HP en los alimentos, fijan su incapacidad para ser eficaces en la batalla.

class Cook_Data
  #--------------------------------------------------------------------------
  # ● Ajuste la referencia de identificador del elemento.
  #--------------------------------------------------------------------------
  def set_cookid
    # A continuación ↓, el establecimiento de
   
    @cookidset[1] = 51
    @cookidset[2] = 52
    @cookidset[3] = 53
    @cookidset[4] = 54
   
    # Hasta ahora ↑
  end
  #--------------------------------------------------------------------------
  # ● Recetas Set
  #--------------------------------------------------------------------------
  def set_cook_recipe
    @recipe[0] = {}  # El valor por defecto (como meterse con).
   
    # A continuación ↓, el establecimiento de
   
    @recipe[1] = {41=>1, 43=>1}
    @recipe[2] = {"a base de arroz"=>1, "cola del sistema"=>2}
    @recipe[3] = {"a base de vegetales"=>2, 41=>1}
    @recipe[4] = {46=>3}
   
    # Hasta ahora ↑
  end
  #--------------------------------------------------------------------------
  # ● El incumplimiento de cocina Set
  #--------------------------------------------------------------------------
  def set_fail_food_id
    # A continuación ↓, el establecimiento de
   
    @fail_food_id[0] = 50  # El valor por defecto
   
    # Hasta ahora ↑
  end
  #--------------------------------------------------------------------------
  # ● No. configuración del interruptor para determinar si los alimentos
  #--------------------------------------------------------------------------
  def set_visible_Switche
    @visible_Switche[0] = 0 # El valor por defecto (como meterse con).
   
    # A continuación ↓, el establecimiento de
   
    @visible_Switche[3] = 20
   
    # Hasta ahora ↑
  end
end

class FoodData
  #--------------------------------------------------------------------------
  # ● Otra dificultad ajustes de compensación experimentado actor
  #--------------------------------------------------------------------------
  def set_actor_cook_difficulty
    @actor_cook_difficulty = []
    @actor_cook_difficulty[0] = 0 # El valor por defecto (como meterse con).
   
    # A continuación ↓, el establecimiento de
   
    case @id #Traducir del: Identificación de Alimentos
    when 1 # musubi
      @actor_cook_difficulty[1] = 0  #Arushesu
      @actor_cook_difficulty[2] = 1  #albahaca
      @actor_cook_difficulty[7] = 0  #Gloria
      @actor_cook_difficulty[8] = 2  #Hilda
    when 2 # conclusión ultra
      @actor_cook_difficulty[1] = 0  #Arushesu
      @actor_cook_difficulty[2] = 1  #albahaca
      @actor_cook_difficulty[7] = -1  #Gloria
      @actor_cook_difficulty[8] = 2  #Hilda
    when 3 # vegetales salteados
      @actor_cook_difficulty[1] = -1  #Arushesu
      @actor_cook_difficulty[2] = 1  #albahaca
      @actor_cook_difficulty[7] = 0  #Gloria
      @actor_cook_difficulty[8] = 2  #Hilda
    when 4 # El ponche de frutas
      @actor_cook_difficulty[1] = -1  #Arushesu
      @actor_cook_difficulty[2] = 1  #albahaca
      @actor_cook_difficulty[7] = 3  #Gloria
      @actor_cook_difficulty[8] = -3  #Hilda
    end
   
    # Hilda ahora ↑
   
  end
  #--------------------------------------------------------------------------
  # ● Agregar los ingredientes Set
  #--------------------------------------------------------------------------
  def set_add_mate
    @add_mate = []
    @add_mate[0] = [nil, nil, nil, nil, nil, nil] # El valor por defecto (no te metas con Koch)
    #El valor por defecto se utiliza cuando un actor no se ha establecido mediante la adición de ingredientes.
    # Por lo tanto, si se trata de add_mate @ [0] Sólo necesito.
    # [nil, nil, nil, 45, nil, nil] pone una parte de la identificación de alimento.
    # Por favor, introduzca el ID de artículo # que se añade a la izquierda cuando la habilidad es 0,1,2,3,4,5.
    # Si desea añadir algo, por favor ponga un cero.
    # Cuando no se utiliza la función, por lo que se determina competencia de habilidad como 0,
    # No utilizar las funciones de expertos de alto nivel, mediante la adición de ingredientes a utilizar actores
    # Si se trata de la ubicación del cero habilidad (extremo izquierdo) Por favor, ponga el identificador de elemento de          #    los        ingredientes añadidos.
    #
    # Cuando se usa con más comida,
    # Alimentos HPSP tasa de recuperación, la recuperación de los valores HPSP, más Estado, menos Estado
    # Recargo será efectiva mientras se está cocinando.
    case @id # Identificación de Alimentos
    when 1 # musubi
      @add_mate[0] = [44, nil, nil, nil, nil, nil] #El valor por defecto
      @add_mate[1] = [45, nil, nil, nil, nil, 46] #Arushesu
      @add_mate[2] = [43, nil, nil, nil, nil, nil] #albahaca
      @add_mate[7] = [nil, nil, nil, nil, nil, nil] #Gloria
      @add_mate[8] = [46, nil, nil, nil, nil, nil] #Hilda
    when 2 # conclusión ultra
      @add_mate[0] = [41, 42, 43, 44, 45, 46] #El valor por defecto
      @add_mate[1] = [41, 42, 43, 44, 45, 46] #Arushesu
      @add_mate[2] = [nil, nil, nil, nil, nil, 42] #albahaca
      @add_mate[7] = [nil, nil, nil, nil, nil, nil] #Gloria
      @add_mate[8] = [46, 46, nil, nil, nil, 46] #Hilda
    when 3 # verduras salteadas
      @add_mate[0] = [41, 42, 43, 44, 45, 46] #El valor por defecto
      @add_mate[1] = [41, 42, 43, 44, 45, 46] #Arushesu
      @add_mate[2] = [nil, nil, nil, nil, nil, 42] #albahaca
      @add_mate[7] = [nil, nil, nil, nil, nil, nil] #Gloria
      @add_mate[8] = [46, nil, nil, nil, 46, 46] #Hilda
    when 4 #Pop colorido inmediatamente Tsu
      @add_mate[0] = [nil, nil, 43, 44, 45, 46] #El valor por defecto
      @add_mate[1] = [nil, nil, 46, nil, nil, nil] #Arushesu
      @add_mate[2] = [nil, nil, nil, nil, nil, 42] #albahaca
      @add_mate[7] = [nil, nil, nil, nil, nil, nil] #Gloria
      @add_mate[8] = [nil, 46, 46, 46, 46, 46] #Hilda
    end
  end
end


class Cook_Data
  attr_reader :cookidset
  attr_reader :recipe
  attr_reader :cookmastery_revise
  attr_reader :cook_difficulty
  attr_reader :fail_food_id
  attr_reader :visible_Switche
  #--------------------------------------------------------------------------
  # ● Inicialización de objetos
  #--------------------------------------------------------------------------
  def initialize
    @cookidset = [0]
    @recipe = []
    @fail_food_id = []
    @visible_Switche = []
    set_cookid
    set_cook_recipe
    set_fail_food_id
    set_visible_Switche
  end
end

class FoodData
  include Cooking_System_Config
  attr_reader :id
  attr_reader :item_id
  attr_reader :name
  attr_reader :icon_name
  attr_reader :description
  attr_reader :recover_hp
  attr_reader :recover_hp_rate
  attr_reader :recover_sp
  attr_reader :recover_sp_rate
  attr_reader :plus_state_set
  attr_reader :minus_state_set
  attr_reader :base_success
  attr_reader :cook_se
  attr_reader :common_event
  attr_reader :recipe
  attr_reader :cookmastery_revise
  attr_reader :cook_difficulty
  attr_reader :fail_food_id
  attr_reader :visible_Switche
  attr_reader :actor_cook_difficulty
  attr_reader :add_mate
  #--------------------------------------------------------------------------
  # ● Inicialización de objetos
  #--------------------------------------------------------------------------
  def initialize(item_id)
    @item_id = item_id              #elemento ID
    @id = set_id                    #set_id
    @name = ""                      #nombre del plato
    @icon_name = ""                  #Icono Nombre de Alimentos
    @description = ""                #Descripción de cocina
    @recover_hp = 0                  #la recuperación de HP
    @recover_hp_rate = 0            #% de recuperación de HP
    @recover_sp = 0                  #valores de recuperación de SP
    @recover_sp_rate = 0            #% de recuperación
    @plus_state_set = []            #Estado de añadir
    @minus_state_set = []            #Estado eliminados
    @base_success = 100              #tasa básica del éxito
    @cook_se = nil                  #SE al cocinar
    @common_event = 0                #Al evento común empieza a cocinar
    @cookmastery_revise = []        #recuperar el nivel de compensación de la habilidad
    @cook_difficulty = []            #cocinar dificultad
   
    @recipe = {}                    #recetas
    @fail_food_id = []              #Artículo fracaso
    @visible_Switche = []            #show número interruptor
    @actor_cook_difficulty = []
    @add_mate = []
    #@need_item = {}                #
    set_up
  end
  #--------------------------------------------------------------------------
  # ●Establece el ID de
  #--------------------------------------------------------------------------
  def set_id
    id = $game_temp.cook_system_data.cookidset.index(@item_id)
    return @id = 0 if id == nil
    return id
  end
  #--------------------------------------------------------------------------
  # ● Cada conjunto de información
  #--------------------------------------------------------------------------
  def set_up
    item = $data_items[@item_id]
    @name = item.name
    @icon_name = item.icon_name
    @description = item.description
    @recover_hp = item.recover_hp
    @recover_hp_rate = item.recover_hp_rate
    @recover_sp = item.recover_sp
    @recover_sp_rate = item.recover_sp_rate
    @plus_state_set = item.plus_state_set
    @minus_state_set = item.minus_state_set
    @base_success = item.hit
    @cook_se = item.menu_se
    @common_event = item.common_event_id
    @cook_difficulty = item.pdef_f
    @cookmastery_revise = item.mdef_f
    @recipe = $game_temp.cook_system_data.recipe[@id]
    if @recipe == nil
      @recipe = {}
    end
    @fail_food_id = $game_temp.cook_system_data.fail_food_id[@id]
    if @fail_food_id == nil
      @fail_food_id = $game_temp.cook_system_data.fail_food_id[0]
    end
    @visible_Switche = $game_temp.cook_system_data.visible_Switche[@id]
    if @visible_Switche == nil
      @visible_Switche = $game_temp.cook_system_data.visible_Switche[0]
    end
    set_actor_cook_difficulty
    set_add_mate
  end
  #--------------------------------------------------------------------------
  # ● Determinar si los alimentos muestran
  #--------------------------------------------------------------------------
  def show?
    return true if @visible_Switche == 0
    return $game_switches[@visible_Switche]
  end
  #--------------------------------------------------------------------------
  # ● Determinar si la comida se
  #--------------------------------------------------------------------------
  def cook_ok?
    need_item = @recipe.keys
    for id in need_item
      if id.is_a?(Numeric)
        return false if $game_party.item_number(id) < @recipe[id]
      elsif id.is_a?(String)
        item_set = food_category(id)
        return false if cook_need_item_number(item_set) < @recipe[id]
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● Devuelve una matriz de ingredientes ID necesario para determinar el nombre de la categoría de ingredientes de los    #alimentos
  #--------------------------------------------------------------------------
  def food_category(str)
    haveitem = $game_party.items.keys
    #haveitem.sort!
    need_item = []
    for id in haveitem
      next if $game_party.item_number(id) <= 0
      item = $data_items[id]
      for i in 0...item.element_set.size
        if $data_system.elements[item.element_set[i]] == str
          need_item.push(id)
          break
        end
      end
    end
    return need_item
  end
  #--------------------------------------------------------------------------
  # ● Devuelve el número de ingredientes necesarios
  #--------------------------------------------------------------------------
  def cook_need_item_number(item_set)
    if item_set.is_a?(Numeric)
      return $game_party.item_number(item_set)
    end
    number = 0
    for id in item_set
      number += $game_party.item_number(id)
    end
    return number
  end
  #--------------------------------------------------------------------------
  # ●El consumo de alimentos procesados
  #--------------------------------------------------------------------------
  def lose_item
    used_item = []
    need_item = @recipe.keys
    for id in need_item
      if id.is_a?(Numeric)
        $game_party.lose_item(id, @recipe[id])
        count = @recipe[id]
        for i in 0...count
          used_item.push(id)
        end
      elsif id.is_a?(String)
        item_set = []
        count = @recipe[id]
        for i in 0...count
          item_set = food_category(id)
          ran = rand(item_set.size)
          $game_party.lose_item(item_set[ran], 1)
          used_item.push(item_set[ran])
        end
      end
    end
    return used_item
  end
  #--------------------------------------------------------------------------
  # ● Efecto de los alimentos
  #--------------------------------------------------------------------------
  def cook_effect(cook_actor, fail=false, add_food=[])
    cm = cook_actor.cookmastery[@id]
    if cm == nil
      cook_actor.cookmastery[@id] = 0
      cm = 0
    end
    cm_r = cm * @cookmastery_revise
    success = @base_success + cm * COOK_SUCCESS_REVISE
    if fail == false
      return false if rand(100) > success
    end
   
    for actor in $game_party.actors
      actor.states_plus(@plus_state_set)
      actor.states_minus(@minus_state_set)
      recover_hp = actor.maxhp * (@recover_hp_rate + cm_r) / 100 + @recover_hp
      recover_sp = actor.maxsp * (@recover_sp_rate + cm_r) / 100 + @recover_sp
      for id in add_food
        item = $data_items[id]
        actor.states_plus(item.plus_state_set)
        actor.states_minus(item.minus_state_set)
        recover_hp += actor.maxhp * item.recover_hp_rate / 100 + item.recover_hp
        recover_sp += actor.maxsp * item.recover_sp_rate / 100 + item.recover_sp
      end
      unless actor.dead?
        actor.hp += recover_hp
        actor.sp += recover_sp
      end
    end
    add_recover_hp_rate = 0
    add_recover_sp_rate = 0
    add_recover_hp = 0
    add_recover_sp = 0
    for id in add_food
      item = $data_items[id]
      add_recover_hp_rate += item.recover_hp_rate
      add_recover_sp_rate += item.recover_sp_rate
      add_recover_hp += item.recover_hp
      add_recover_sp += item.recover_sp
    end
    $game_temp.temp_recover_hp_rate = @recover_hp_rate + cm_r + add_recover_hp_rate
    $game_temp.temp_recover_sp_rate = @recover_sp_rate + cm_r + add_recover_sp_rate
    $game_temp.temp_recover_hp = @recover_hp + add_recover_hp
    $game_temp.temp_recover_sp = @recover_sp + add_recover_sp
   
    #Dominio cada vez mayor después del tratamiento
    if USE_COOK_MASTERY and fail == false
      if cook_actor.cookmastery[@id] < MAX_COOK_MASTERY
        if cook_actor.cookmastery_exp[@id] == nil
          cook_actor.cookmastery_exp[@id] = 1
        else
          cook_actor.cookmastery_exp[@id] += 1
        end
        if COOK_TYPE_SELECT == 1
          actor_difficulty = @actor_cook_difficulty[cook_actor.id]
        else
          actor_difficulty = 0
        end
        if actor_difficulty == nil
          actor_difficulty = @actor_cook_difficulty[0]
        end
        if cook_actor.cookmastery_exp[@id] >= @cook_difficulty + actor_difficulty
          cook_actor.cookmastery[@id] += 1
          cook_actor.cookmastery_exp[@id] = 0
        end
      end
    end
   
    # Cuando el identificador de suceso común está habilitado
    if @common_event > 0
      # Evento común de reserva llame al
      $game_temp.common_event_id = @common_event
    end
    return true
  end
end

class Game_Temp
  attr_reader :food_data
  attr_reader :cook_system_data
  attr_accessor :temp_recover_hp
  attr_accessor :temp_recover_hp_rate
  attr_accessor :temp_recover_sp
  attr_accessor :temp_recover_sp_rate
  attr_accessor :cookmastery
  alias temp_cook_system_data_initialize initialize
  def initialize
    temp_cook_system_data_initialize
    @cook_system_data = Cook_Data.new
    @food_data = nil
    @temp_recover_hp = 0
    @temp_recover_hp_rate = 0
    @temp_recover_sp = 0
    @temp_recover_sp_rate = 0
    #set_food_data
  end
  def set_food_data
    @food_data = []
    for i in 1...@cook_system_data.cookidset.size
      @food_data[i] = FoodData.new(@cook_system_data.cookidset[i])
    end
  end
end

class Game_Party
  attr_accessor :cookmastery
  attr_accessor :cookmastery_exp
  attr_accessor :cook_battle_count
  attr_reader :items
  #--------------------------------------------------------------------------
  # ● Inicialización de objetos
  #--------------------------------------------------------------------------
  alias cook_system_game_party_initialize initialize
  def initialize
    cook_system_game_party_initialize
    @cookmastery = {}
    @cookmastery_exp = {}
    @cook_battle_count = 0
  end
end

class Game_Actor < Game_Battler
  attr_accessor :cookmastery
  attr_accessor :cookmastery_exp
  #--------------------------------------------------------------------------
  # ● Inicialización de objetos
  # Actor_id: ID actor
  #--------------------------------------------------------------------------
  alias cook_system_game_actor_initialize initialize
  def initialize(actor_id)
    cook_system_game_actor_initialize(actor_id)
    @cookmastery = {}
    @cookmastery_exp = {}
  end
end

class Scene_Map
  #--------------------------------------------------------------------------
  # ● Llamada a la batalla
  #--------------------------------------------------------------------------
  alias cook_system_call_battle call_battle
  def call_battle
    # Puede contar con alimentos para disminuir la
    if $game_party.cook_battle_count != 0
      $game_party.cook_battle_count -= 1
    end
    cook_system_call_battle
  end
end

class Window_CookMenu < Window_Selectable
  attr_reader :data
  #--------------------------------------------------------------------------
  # ● Inicialización de objetos
  #--------------------------------------------------------------------------
  def initialize
    super(0, 288, 640, 192)
    @column_max = 2
    refresh
    self.index = 0
  end
  #--------------------------------------------------------------------------
  # ● Adquisición de un elemento
  #--------------------------------------------------------------------------
  def item
    return @data[self.index]
  end
  #--------------------------------------------------------------------------
  # ● refrescar
  #--------------------------------------------------------------------------
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = $game_temp.food_data.dup
    @data.shift
    # Crear un número de artículo de mapa de bits no es cero, todos los elementos dibujados
    @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
  #--------------------------------------------------------------------------
  # ● Elemento de dibujo
  # Índice: número de artículo
  #--------------------------------------------------------------------------
  def draw_item(index)
    item = @data[index]
    if item.cook_ok?
      self.contents.font.color = normal_color
    else
      self.contents.font.color = disabled_color
    end
    x = 4 + index % 2 * (288 + 32)
    y = index / 2 * 32
    if item.show?
      rect = Rect.new(x, y, self.width / @column_max - 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, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
      self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)
    else
      self.contents.draw_text(x + 28, y, 212, 32, "-----", 0)
    end
  end
  #--------------------------------------------------------------------------
  # ● Actualizar el texto de ayuda
  #--------------------------------------------------------------------------
  def update_help
    if self.item.show?
      @help_window.set_text(self.item == nil ? "" : self.item.description)
    else
      @help_window.set_text("")
    end
  end
end

class Window_FoodInfo < Window_Base
  #--------------------------------------------------------------------------
  # ● Inicialización de objetos
  #--------------------------------------------------------------------------
  def initialize
    super(0, 128, 640, 160)
    self.contents = Bitmap.new(width - 32, height - 32)
    @item = nil
  end
  #--------------------------------------------------------------------------
  # ● refrescar
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    if @item == nil
      return
    end
    if @item.show? == false
      return
    end
    item_set = @item.recipe.keys
    need_number = []
    for i in item_set
      if i.is_a?(String)
        temp = @item.food_category(i)
        need_number.push(@item.cook_need_item_number(temp))
      else
        need_number.push(@item.cook_need_item_number(i))
      end
    end
    for i in 0...item_set.size
      x = 4 + i % 2 * (288 + 32)
      y = i / 2 * 32
      if item_set[i].is_a?(Numeric)
        now_num = $game_party.item_number(item_set[i])
        max_num = @item.recipe[item_set[i]]
        if now_num < max_num
          self.contents.font.color = disabled_color
          opacity = 128
        else
          self.contents.font.color = normal_color
          opacity = 255
        end
        item = $data_items[item_set[i]]
        name = item.name
        rect = Rect.new(x, y, self.width / 2 - 32, 32)
        self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
        bitmap = RPG::Cache.icon(item.icon_name)
        self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
        self.contents.draw_text(x + 28, y, 212, 32, name, 0)
      elsif item_set[i].is_a?(String)
        now_num = need_number[i]
        max_num = @item.recipe[item_set[i]]
        if now_num < max_num
          self.contents.font.color = disabled_color
        else
          self.contents.font.color = normal_color
        end
        name = item_set[i].to_s
        self.contents.draw_text(x + 28, y, 212, 32, name, 0)
      end
      self.contents.draw_text(x + 212, y, 24, 32, max_num.to_s, 2)
      self.contents.font.color = normal_color
      self.contents.draw_text(x + 240, y, 16, 32, "/", 1)
      self.contents.draw_text(x + 256, y, 24, 32, now_num.to_s, 2)
    end
  end
  #--------------------------------------------------------------------------
  # ● Artículo Set
  # Artículo: nuevo elemento
  #--------------------------------------------------------------------------
  def item=(item)
    if @item != item
      @item = item
      refresh
    end
  end
end

class Window_CookSelect < Window_Selectable
  include Cooking_System_Config
  #--------------------------------------------------------------------------
  # ●Inicialización de objetos
  #--------------------------------------------------------------------------
  def initialize
    super(0, 288, 640, 192)
    @column_max = 2
    self.contents = Bitmap.new(width - 32, height - 32)
    if COOK_TYPE_SELECT == 1
      @data = $game_party.actors
    else
      @data = [$game_party]
    end
    @item_max = @data.size
    @cookitem = nil
    self.index = 0
  end
  #--------------------------------------------------------------------------
  # ● actor Obtiene
  #--------------------------------------------------------------------------
  def actor
    return @data[self.index]
  end
  #--------------------------------------------------------------------------
  # ● refrescar
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    if @cookitem == nil
      return
    end
    for i in 0...@data.size
      actor = @data[i]
      x = 4 + i % 2 * (288 + 32)
      y = i / 2 * 64
      self.contents.font.color = normal_color
      if COOK_TYPE_SELECT == 1
        self.contents.draw_text(x, y, 160, 32, actor.name, 0)
      else
        self.contents.draw_text(x, y, 160, 32, "Ejecutar los alimentos", 0)
      end
      if USE_COOK_MASTERY
        cm = actor.cookmastery[@cookitem.id]
        cm = 0 if cm == nil
        hosi = "★" * cm
        hosi2= "☆" * (MAX_COOK_MASTERY - cm)
        self.contents.draw_text(x, y+32, 320, 32, hosi+hosi2, 0)
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● Artículo Set
  # Artículo: nuevo elemento
  #--------------------------------------------------------------------------
  def item=(item)
    if @cookitem != item
      @cookitem = item
      refresh
    end
  end
  #--------------------------------------------------------------------------
  # ● Actualización del cursor rectangular
  #--------------------------------------------------------------------------
  def update_cursor_rect
    if @index < 0
      self.cursor_rect.empty
    else
      x = @index % @column_max * 320
      y = @index / @column_max * 64
      self.cursor_rect.set(x, y, 160, 32)
    end
  end
end

class Window_CookResult < Window_Base
  #--------------------------------------------------------------------------
  # ● Inicialización de objetos
  #--------------------------------------------------------------------------
  def initialize
    super(80, 60, 480, 160)
    self.contents = Bitmap.new(width - 32, height - 32)
  end
  #--------------------------------------------------------------------------
  # ● refrescar
  #--------------------------------------------------------------------------
  def refresh(item, success)
    self.contents.clear
    self.contents.font.color = normal_color
    self.contents.draw_text(4, 0, 64, 32, "cocina", 0)
    if success
      self.contents.font.color = system_color
      str = "éxito!"
    else
      self.contents.font.color = text_color(2)
      str = "fracaso…"
    end
    self.contents.draw_text(4+64, 0, 96, 32, str, 0)
    self.contents.font.color = normal_color
    rect = Rect.new(4, 32, self.width - 32, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    bitmap = RPG::Cache.icon(item.icon_name)
    opacity = 255
    hprate = $game_temp.temp_recover_hp_rate
    sprate = $game_temp.temp_recover_sp_rate
    hp = $game_temp.temp_recover_hp
    sp = $game_temp.temp_recover_sp
    self.contents.blt(4, 32 + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
    self.contents.draw_text(4 + 28, 32, 212, 32, item.name, 0)
    self.contents.draw_text(4 + 240, 32, 96, 32, "terminado!", 0)
    self.contents.draw_text(4, 64, 64, 32, $data_system.words.hp, 0)
    self.contents.draw_text(4 + 96, 64, 64, 32, hprate.to_s+"%", 2)
    self.contents.draw_text(4 + 160, 64, 32, 32, "+", 1)
    self.contents.draw_text(4 + 224, 64, 64, 32, hp.to_s, 2)
    self.contents.draw_text(4, 96, 64, 32, $data_system.words.sp, 0)
    self.contents.draw_text(4 + 96, 96, 64, 32, sprate.to_s+"%", 2)
    self.contents.draw_text(4 + 160, 96, 32, 32, "+", 1)
    self.contents.draw_text(4 + 224, 96, 64, 32, sp.to_s, 2)
  end
end

class Window_Use_CookItem < Window_Base
  #--------------------------------------------------------------------------
  # ● Inicialización de objetos
  #--------------------------------------------------------------------------
  def initialize
    super(80, 220, 480, 192)
    self.contents = Bitmap.new(width - 32, height - 32)
  end
  #--------------------------------------------------------------------------
  # ●refrescar
  #--------------------------------------------------------------------------
  def refresh(useitem, use_add_food)
    self.contents.clear
    self.contents.font.color = normal_color
    self.contents.draw_text(4, 0, 160, 32, "Los ingredientes utilizados", 0)
    total_food = useitem + use_add_food
    for i in 0...total_food.size
      item = $data_items[total_food[i]]
      x = 4  + i % 2 * 240
      y = 32 + i / 2 * 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 = 255
      self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
      if i < useitem.size
        self.contents.font.color = normal_color
      else
        self.contents.font.color = text_color(3)
      end
      self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)
    end
  end
end

class Window_Add_Mate < Window_Base
  #--------------------------------------------------------------------------
  # ● Inicialización de objetos
  #--------------------------------------------------------------------------
  def initialize
    super(0, 128, 640, 160)
    self.contents = Bitmap.new(width - 32, height - 32)
  end
 
  #--------------------------------------------------------------------------
  # ● refrescar
  #--------------------------------------------------------------------------
  def refresh(useitem)
    self.contents.clear
    self.contents.font.color = normal_color
    self.contents.draw_text(4, 0, 160, 32, "Agregar los ingredientes", 0)
    for i in 0...useitem.size
      item = $data_items[useitem[i]]
      x = 4  + i % 2 * 240
      y = 32 + i / 2 * 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 = 255
      self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
      self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)
    end
  end
end

class Scene_Cooking
  include Cooking_System_Config
  #--------------------------------------------------------------------------
  # ● el proceso principal
  #--------------------------------------------------------------------------
  def main
    $game_temp.set_food_data if $game_temp.food_data == nil
    # Crear una ventana
    @title_window = Window_Base.new(0, 0, 640, 64)
    @title_window.contents = Bitmap.new(640 - 32, 64 - 32)
    @title_window.contents.draw_text(4, 0, 320, 32, "cocina", 0)
    @main_window = Window_CookMenu.new
    @main_window.active = true
    @help_window = Window_Help.new
    @help_window.z = 110
    @help_window.y = 64
    @help_window.visible = true
    s1 = "Ejecutar los alimentos"
    s2 = "dejar de"
    command = [s1, s2]
    @select_window = Window_CookSelect.new #Window_Command.new(160, command)
    @select_window.z = 110
    @select_window.active = false
    @select_window.visible = false
    @add_mate_window = Window_Add_Mate.new
    @add_mate_window.z = 120
    @add_mate_window.visible = false
    # Crear una ventana de información.
    @info_window = Window_FoodInfo.new
    # Asociado con la ventana Ayuda
    @main_window.help_window = @help_window
    # RUN
    Graphics.transition
    # bucle principal
    loop do
      # Actualización de la pantalla del juego
      Graphics.update
      # Actualizar la información de entrada
      Input.update
      # marco de actualización
      update
      # Abortar bucle si la pantalla se cambia
      if $scene != self
        break
      end
    end
    # Preparación de la transición
    Graphics.freeze
    # Libera la ventana
    @title_window.dispose
    @help_window.dispose
    @main_window.dispose
    @select_window.dispose
    @info_window.dispose
    @add_mate_window.dispose
  end
  #--------------------------------------------------------------------------
  # ● marco de actualización
  #--------------------------------------------------------------------------
  def update
    # La actualización de Windows
    @help_window.update
    @main_window.update
    @select_window.update
    @info_window.update
    @add_mate_window.update
    if @result_window != nil
      update_result
      return
    end
    # La ventana principal está activo: update_target llamada
    if @main_window.active
      update_main
      return
    end
    #Tipo de ventana activa: update_kind llamada
    if @select_window.active
      update_select
      return
    end
  end
  #--------------------------------------------------------------------------
  # ●Marco de actualización (de la ventana activa se selecciona)
  #--------------------------------------------------------------------------
  def update_select
    if USE_COOK_MATE_ADD and ADD_MATE_SHOW
      #Añadir los ingredientes ventana
      if @select_window.index != @select_w_last_index
        @add_mate_window.visible = true
        @select_w_last_index = @select_window.index
        add_food = actor_add_mate(@main_window.item, @select_window.actor)
        @add_mate_window.refresh(add_food)
      end
    end
    # Botón C se presiona
    if Input.trigger?(Input::C)
      if $game_party.cook_battle_count > 0 or
        (COOK_TYPE_SELECT == 1 and @select_window.actor.dead?)
        # Juega timbre SE
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      use_item = @main_window.item.lose_item
     
      if USE_COOK_MATE_ADD
        add_food = actor_add_mate(@main_window.item, @select_window.actor)
        have_add_food = []
        for food_id in add_food
          if $game_party.item_number(food_id) > 0
            have_add_food.push(food_id)
            $game_party.lose_item(food_id, 1)
          end
        end
        result = @main_window.item.cook_effect(@select_window.actor, false, have_add_food)
      else
        result = @main_window.item.cook_effect(@select_window.actor)
      end
      if result
        $game_system.se_play(@main_window.item.cook_se)
        @result_window = Window_CookResult.new
        @result_window.refresh(@main_window.item, result)
      else
        @fail_food = FoodData.new(@main_window.item.fail_food_id)
        @fail_food.cook_effect(@select_window.actor, true)
        $game_system.se_play(@fail_food.cook_se)
        @result_window = Window_CookResult.new
        @result_window.refresh(@fail_food, result)
      end
      use_add_food = []
      if USE_COOK_MATE_ADD
        use_add_food = have_add_food
      end
      if use_item.size != 0 or use_add_food.size != 0
        @useitem_window = Window_Use_CookItem.new
        @useitem_window.refresh(use_item, use_add_food)
        @useitem_window.z = 130
      end
      @info_window.refresh
      @result_window.z = 130
      return
    end
    # Botón B se presiona
    if Input.trigger?(Input::B)
      # Jugar SE Cancelar
      $game_system.se_play($data_system.cancel_se)
      @main_window.active = true
      @select_window.active = false
      @select_window.visible = false
      @add_mate_window.visible = false
      @select_w_last_index = nil
      return
    end
    if USE_COOK_MATE_ADD and ADD_MATE_SHOW
      # Un botón que se pulsa
      if Input.trigger?(Input::A)
        # Jugando la determinación SE
        $game_system.se_play($data_system.decision_se)
        if @add_mate_window.visible
          @add_mate_window.visible = false
        else
          @add_mate_window.visible = true
        end
        return
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● Actualización del marco (ventana principal está activo).
  #--------------------------------------------------------------------------
  def update_main
    @info_window.item = @main_window.data[@main_window.index]
    # Botón B se presiona
    if Input.trigger?(Input::B)
      # Jugar SE Cancelar
      $game_system.se_play($data_system.cancel_se)
      $scene = Scene_Map.new
      return
    end
    # Botón C se presiona
    if Input.trigger?(Input::C)
      if @main_window.item == nil or
        @main_window.item.show? == false or
        @main_window.item.cook_ok? == false
        # Juega timbre SE
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Jugando la determinación SE
      $game_system.se_play($data_system.decision_se)
      @main_window.active = false
      @select_window.active = true
      @select_window.visible = true
      @select_window.item = @main_window.data[@main_window.index]
      @select_window.refresh
      return
    end
  end
  #--------------------------------------------------------------------------
  # ● Actualización del marco (ventana de resultados está activo).
  #--------------------------------------------------------------------------
  def update_result
    # Botón C se presiona
    if Input.trigger?(Input::C)
      # Jugando la determinación SE
      $game_system.se_play($data_system.decision_se)
      @result_window.dispose
      @result_window = nil
      if @useitem_window != nil
        @useitem_window.dispose
        @useitem_window = nil
      end
      @main_window.active = true
      @main_window.refresh
      @select_window.active = false
      @select_window.visible = false
      @add_mate_window.visible = false
      @select_w_last_index = nil
      $game_party.cook_battle_count = COOK_BATTLE_COUNT
      if $game_temp.common_event_id > 0
        # Cambie a la pantalla del mapa
        $scene = Scene_Map.new
        return
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● Agregar los ingredientes para volver
  #--------------------------------------------------------------------------
  def actor_add_mate(food, actor=nil)
    #Obtener material adicional
    if COOK_TYPE_SELECT == 1
      if USE_ACTOR_MATE_ADD
        useitem = food.add_mate[actor.id]
      else
        useitem = food.add_mate[0]
      end 
    else
      useitem = food.add_mate[0]
    end
    return [] if useitem == nil
    return [] if useitem.size == 0
    #Si usted ha adquirido la característica de competencia de habilidad se utiliza
    if USE_COOK_MASTERY
      cm = actor.cookmastery[food.id]
      cm = 0 if cm == nil
    else
      cm = 0
    end
    temp_item = []
    for i in 0..cm
      next if useitem[i] == nil
      temp_item.push(useitem[i])
    end
    return temp_item
  end
end

Creditos:
momomomo



Última edición por ~thekiller el Lun Dic 12, 2011 10:43 pm, editado 1 vez

JMB GISOKA

avatar
~thekiller tendrias que traducir el script al español con Google traductor para que
los usuarios comprendan el script por que no creo que sepan Jpones pero
igualmente BUEN APORTE pero seria mejor que lo traduzcas al Español

#3 Re: [RPG Maker XP] Script: Mini juego de cocina. el Dom Ago 12, 2012 12:35 pm

julydis

avatar
Hola, me gustaría poner este script en mi jugo, pero tengo una duda ¿Como hago para entrar en el menú de cocinar? ¿Debo añadir algo en el menú principal?

jehyknaria

avatar
julydis escribió:Hola, me gustaría poner este script en mi jugo, pero tengo una duda ¿Como hago para entrar en el menú de cocinar? ¿Debo añadir algo en el menú principal?
Debes utilizar el comando llamar script y poner: $scene = Scene_Cooking.new

Espero que esto no se considere necreoposting, ya que es una duda y no se dice en el post.

#5 Re: [RPG Maker XP] Script: Mini juego de cocina. el Sáb Ago 18, 2012 11:56 am

julydis

avatar
Muchas gracias Ópalo Sonriente, de todo corazón, lo estuve buscando pero no lo encontraba por ningún sitio, por eso pregunte.

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.