Mundo Maker
¡Bienvenid@ a Mundo Maker!

¿Quieres aprender todo sobre el RPG Maker?



Regístrate y forma parte de Mundo Maker.
Conectarse

Recuperar mi contraseña

Temas importantes
----------------------------------------
Páginas con recursos RPG Maker
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
Afiliados
Estadísticas
Tenemos 3766 miembros registrados.
El último usuario registrado es stranger2525.

Nuestros miembros han publicado un total de 85792 mensajes en 12216 argumentos.

[XP] Multiple Game_Party IDs

Ver el tema anterior Ver el tema siguiente Ir abajo

RPG Maker XP [XP] Multiple Game_Party IDs

Mensaje por Wecoc el 2016-11-30, 07:24

Hice una modificación del script base Game_Party para que soporte diferentes Party IDs. Eso significa que puedes separar la party en varias, cada una con sus actores, sus objetos, su dinero, etc. y cambiar de un grupo a otro mediante un comando.

Pese a ser una modificación bastante rudimentaria su uso puede llegar a ser bastante complicado para según qué casos, así que recomiendo usarlo solo si tenéis una base de RGSS. Además que quede claro que solo es una modificación de Game_Party, controles extra como qué hacer si todos los miembros de un grupo están muertos pero hay otros grupos disponibles y esas cosas (eso ya no solo afecta a Game_Party) se tendrán que hacer a parte, por defecto solo va a Game Over si todos los miembros de todos los grupos están muertos.

Además posiblemente haya que combinarlo con engines para lograr un efecto convincente de cambio de grupo.

Script: (ponedlo encima de main y de cualquier otro script personalizado)

Código:
#==============================================================================
# ** [XP] Multiple Game_Party IDs v1.0
#------------------------------------------------------------------------------
#  Autor: Wecoc - No requiere créditos
#==============================================================================

class Game_Party
  #--------------------------------------------------------------------------
  MAX_ACTORS = 4
  MAX_ITEMS  = 99
  MAX_GOLD  = 9999999
  #--------------------------------------------------------------------------
  attr_reader :party_id
  #--------------------------------------------------------------------------
  def initialize
    @actors = {}
    @gold  = {}
    @steps  = {}
    @gold.default  = 0
    @steps.default = 0
    @items  = {}
    @weapons = {}
    @armors  = {}
    @items.default  = {}
    @weapons.default = {}
    @armors.default  = {}
    @party_id = 0
  end
  #--------------------------------------------------------------------------
  def set(party_id)
    @party_id = party_id
    refresh
  end
  #--------------------------------------------------------------------------
  def actors(party_id=@party_id)
    return [] if @actors[party_id].nil?
    return @actors[party_id]
  end
  #--------------------------------------------------------------------------
  def items(party_id=@party_id)
    return {} if @items[party_id].nil?
    return @items[party_id]
  end
  #--------------------------------------------------------------------------
  def weapons(party_id=@party_id)
    return {} if @weapons[party_id].nil?
    return @weapons[party_id]
  end
  #--------------------------------------------------------------------------
  def armors(party_id=@party_id)
    return {} if @armors[party_id].nil?
    return @armors[party_id]
  end
  #--------------------------------------------------------------------------
  def gold(party_id=@party_id)
    return @gold[party_id]
  end
  #--------------------------------------------------------------------------
  def steps(party_id=@party_id)
    return @steps[party_id]
  end
  #--------------------------------------------------------------------------
  def setup_starting_members
    @party_id = 0 if @party_id.nil?
    @actors[@party_id] = []
    for i in $data_system.party_members
      @actors[@party_id].push($game_actors[i])
    end
  end
  #--------------------------------------------------------------------------
  def setup_battle_test_members
    @party_id = 0 if @party_id.nil?
    @actors[@party_id] = []
    for battler in $data_system.test_battlers
      actor = $game_actors[battler.actor_id]
      actor.level = battler.level
      gain_weapon(battler.weapon_id, 1)
      gain_armor(battler.armor1_id, 1)
      gain_armor(battler.armor2_id, 1)
      gain_armor(battler.armor3_id, 1)
      gain_armor(battler.armor4_id, 1)
      actor.equip(0, battler.weapon_id)
      actor.equip(1, battler.armor1_id)
      actor.equip(2, battler.armor2_id)
      actor.equip(3, battler.armor3_id)
      actor.equip(4, battler.armor4_id)
      actor.recover_all
      @actors[@party_id].push(actor)
    end
    @items[@party_id] = {}
    for i in 1...$data_items.size
      if $data_items[i].name != ""
        occasion = $data_items[i].occasion
        if occasion == 0 or occasion == 1
          @items[@party_id][i] = MAX_ITEMS
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  def refresh
    new_actors = []
    for i in 0...self.actors.size
      if $data_actors[self.actors[i].id] != nil
        new_actors.push($game_actors[self.actors[i].id])
      end
    end
    @actors[@party_id] = new_actors
    $game_player.refresh
  end
  #--------------------------------------------------------------------------
  def max_level
    return 0 if self.actors.size == 0
    level = 0
    for actor in self.actors
      if level < actor.level
        level = actor.level
      end
    end
    return level
  end
  #--------------------------------------------------------------------------
  def add_actor(actor_id, party_id=@party_id)
    actor = $game_actors[actor_id]
    if @actors[party_id].size < MAX_ACTORS
      if !@actors[party_id].include?(actor)
        @actors[party_id].push(actor)
        $game_player.refresh
      end
    end
  end
  #--------------------------------------------------------------------------
  def remove_actor(actor_id, party_id=@party_id)
    @actors[party_id].delete($game_actors[actor_id])
    $game_player.refresh
  end
  #--------------------------------------------------------------------------
  def move_actor(actor_id, current_party_id, new_party_id)
    actor = $game_actors[actor_id]
    return if !@actors[current_party_id].include?(actor)
    return if @actors[new_party_id].size == MAX_ACTORS
    add_actor(actor_id, new_party_id)
    remove_actor(actor_id, current_party_id)
  end
  #--------------------------------------------------------------------------
  def get_actor_party_id(actor)
    for i in @actors.keys
      if @actors[i].any? { |a| a.id == actor.id }
        return i
      end
    end
  end
  #--------------------------------------------------------------------------
  def gain_gold(n, party_id=@party_id)
    @gold[party_id] = [[@gold[party_id] + n, 0].max, MAX_GOLD].min
  end
  #--------------------------------------------------------------------------
  def lose_gold(n, party_id=@party_id)
    gain_gold(-n, party_id)
  end
  #--------------------------------------------------------------------------
  def move_gold(n, current_party_id, new_party_id)
    return if n == 0
    return move_gold(-n, new_party_id, current_party_id) if n < 0
    cn = [n, @gold[current_party_id]].min
    n = [cn, MAX_GOLD - @gold[new_party_id]].min
    gain_gold(n, new_party_id)
    lose_gold(n, current_party_id)
  end
  #--------------------------------------------------------------------------
  def increase_steps(party_id=@party_id)
    @steps[party_id] += 1
  end
  #--------------------------------------------------------------------------
  def set_steps(n, party_id=@party_id)
    @steps[party_id] = [n, 0].max
  end
  #--------------------------------------------------------------------------
  def item_number(item_id, party_id=@party_id)
    return 0 if !@items[party_id].include?(item_id)
    return @items[party_id][item_id]
  end
  #--------------------------------------------------------------------------
  def weapon_number(weapon_id, party_id=@party_id)
    return 0 if !@weapons[party_id].include?(weapon_id)
    return @weapons[party_id][weapon_id]
  end
  #--------------------------------------------------------------------------
  def armor_number(armor_id)
    return 0 if !@armors[party_id].include?(armor_id)
    return @armors[party_id][armor_id]
  end
  #--------------------------------------------------------------------------
  def gain_item(item_id, n, party_id=@party_id)
    return if item_id <= 0
    number = item_number(item_id, party_id)
    @items[party_id][item_id] = [[number + n, 0].max, MAX_ITEMS].min
  end
  #--------------------------------------------------------------------------
  def lose_item(item_id, n, party_id=@party_id)
    gain_item(item_id, -n, party_id)
  end
  #--------------------------------------------------------------------------
  def move_item(item_id, n, current_party_id, new_party_id)
    return if n == 0
    return move_item(item_id, -n, new_party_id, current_party_id) if n < 0
    cn = [n, item_number(item_id, current_party_id)].min
    n = [cn, MAX_ITEMS - item_number(item_id, new_party_id)].min
    gain_item(item_id, n, new_party_id)
    lose_item(item_id, n, current_party_id)
  end
  #--------------------------------------------------------------------------
  def gain_weapon(weapon_id, n, party_id=@party_id)
    return if weapon_id <= 0
    number = weapon_number(weapon_id, party_id)
    @weapons[party_id][weapon_id] = [[number + n, 0].max, MAX_ITEMS].min
  end
  #--------------------------------------------------------------------------
  def lose_weapon(weapon_id, n, party_id=@party_id)
    gain_weapon(weapon_id, -n, party_id)
  end
  #--------------------------------------------------------------------------
  def move_weapon(weapon_id, n, current_party_id, new_party_id)
    return if n == 0
    return move_weapon(weapon_id, -n, new_party_id, current_party_id) if n < 0
    cn = [n, weapon_number(weapon_id, current_party_id)].min
    n = [cn, MAX_ITEMS - weapon_number(weapon_id, new_party_id)].min
    gain_weapon(weapon_id, n, new_party_id)
    lose_weapon(weapon_id, n, current_party_id)
  end
  #--------------------------------------------------------------------------
  def gain_armor(armor_id, n, party_id=@party_id)
    return if armor_id <= 0
    number = armor_number(armor_id, party_id)
    @armors[party_id][armor_id] = [[number + n, 0].max, MAX_ITEMS].min
  end
  #--------------------------------------------------------------------------
  def lose_armor(armor_id, n, party_id=@party_id)
    gain_armor(armor_id, -n, party_id)
  end
  #--------------------------------------------------------------------------
  def move_armor(armor_id, n, current_party_id, new_party_id)
    return if n == 0
    return move_armor(armor_id, -n, new_party_id, current_party_id) if n < 0
    cn = [n, armor_number(armor_id, current_party_id)].min
    n = [cn, MAX_ITEMS - armor_number(armor_id, new_party_id)].min
    gain_armor(armor_id, n, new_party_id)
    lose_armor(armor_id, n, current_party_id)
  end
  #--------------------------------------------------------------------------
  def item_can_use?(item_id, party_id=@party_id)
    return false if item_number(item_id, party_id) == 0
    occasion = $data_items[item_id].occasion
    if $game_temp.in_battle
      return (occasion == 0 or occasion == 1)
    end
    return (occasion == 0 or occasion == 2)
  end
  #--------------------------------------------------------------------------
  def clear_actions
    for actor in self.actors
      actor.current_action.clear
    end
  end
  #--------------------------------------------------------------------------
  def inputable?
    for actor in self.actors
      return true if actor.inputable?
    end
    return false
  end
  #--------------------------------------------------------------------------
  def all_dead?(party_id=nil)
    return all_dead_all_parties? if party_id == nil
    return true if @actors[party_id].size == 0
    for actor in @actors[party_id]
      return false if actor.hp > 0
    end
    return true
  end
  #--------------------------------------------------------------------------
  def all_dead_all_parties?
    return @actors.all?{|party| party.all_dead?}
  end
  #--------------------------------------------------------------------------
  def check_map_slip_damage
    for actor in self.actors
      if actor.hp > 0 and actor.slip_damage?
        actor.hp -= [actor.maxhp / 100, 1].max
        if actor.hp == 0
          $game_system.se_play($data_system.actor_collapse_se)
        end
        $game_screen.start_flash(Color.new(255,0,0,128), 4)
        $game_temp.gameover = $game_party.all_dead?
      end
    end
  end
  #--------------------------------------------------------------------------
  def random_target_actor(hp0 = false)
    roulette = []
    for actor in self.actors
      if (not hp0 and actor.exist?) or (hp0 and actor.hp0?)
        position = $data_classes[actor.class_id].position
        n = 4 - position
        n.times { roulette.push(actor) }
      end
    end
    return nil if roulette.size == 0
    return roulette[rand(roulette.size)]
  end
  #--------------------------------------------------------------------------
  def random_target_actor_hp0
    return random_target_actor(true)
  end
  #--------------------------------------------------------------------------
  def smooth_target_actor(actor_index)
    actor = self.actors[actor_index]
    return actor if actor != nil and actor.exist?
    for actor in self.actors
      return actor if actor.exist?
    end
  end
end

Cada party tiene un máximo de actores, dinero y objetos que se puede cambiar al principio del script.

Métodos:

En verde los que van como siempre, en blanco los nuevos y en naranja los avanzados.

Argumentos:

PARTY ID - Numérico. Índice de la party. Por defecto vale 0.
ACTOR ID - Numérico. Índice del actor en la Base de Datos.
ACTOR - Game_Actor. Se obtiene usando $game_actors[ACTOR ID]
GOLD - Numérico. Dinero.
STEPS - Numérico. Pasos.
ITEM/WEAPON/ARMOR ID - Numérico. Índice del objeto/arma/protector en la Base de Datos.
NUMBER - Numérico. Valor (número de objetos, armas, protectores con el que se interactúa)

Obtener datos almacenados:
MÉTODODESCRIPCIÓN
$game_party.actorsDevuelve los actores de la party actual
$game_party.actors(PARTY ID)Devuelve los actores de una party
$game_party.itemsDevuelve los objetos de la party actual
$game_party.items(PARTY ID)Devuelve los objetos de una party
$game_party.weaponsDevuelve las armas (no usadas) de la party actual
$game_party.weapons(PARTY ID)Devuelve las armas (no usadas) de una party
$game_party.armorsDevuelve los protectores (no usados) de la party actual
$game_party.armors(PARTY ID)Devuelve los protectores (no usados) de una party
$game_party.goldDevuelve el dinero de la party actual
$game_party.gold(PARTY ID)Devuelve el dinero de una party
$game_party.stepsDevuelve los pasos de la party actual
$game_party.steps(PARTY ID)Devuelve los pasos de una party
$game_party.max_levelDevuelve el nivel más alto de los actores de la party actual

Interacciones:
MÉTODODESCRIPCIÓN
$game_party.set(PARTY ID)Cambia de ID la party
$game_party.add_actor(ACTOR ID)Añade un actor a la party actual
$game_party.add_actor(ACTOR ID, PARTY ID)Añade un actor a una party
$game_party.remove_actor(ACTOR ID)Quita un actor a la party actual
$game_party.remove_actor(ACTOR ID, PARTY ID)Quita un actor a una party
$game_party.move_actor(ACTOR ID, CURRENT PARTY ID, NEW PARTY ID)Mueve un actor de una party a otra
$game_party.get_actor_party_id(ACTOR)Obtiene la ID de party en la que se encuentra un actor
$game_party.gain_gold(GOLD)Incrementa el dinero de la party actual
$game_party.gain_gold(GOLD, PARTY ID)Incrementa el dinero de una party
$game_party.lose_gold(GOLD)Disminuye el dinero de la party actual
$game_party.lose_gold(GOLD, PARTY ID)Disminuye el dinero de una party
$game_party.move_gold(GOLD, CURRENT PARTY ID, NEW PARTY ID)Mueve dinero de una party a otra
$game_party.increase_stepsIncrementa un paso
$game_party.increase_steps(PARTY ID)Incrementa un paso en una party
$game_party.set_steps(STEPS)Define el número de pasos en la party actual
$game_party.set_steps(STEPS, PARTY ID)Define el número de pasos en una party
$game_party.item_number(ITEM ID)Obtiene el número que contiene la party actual de un determinado objeto
$game_party.item_number(ITEM ID, PARTY ID)Obtiene el número que contiene una party de un determinado objeto
$game_party.weapon_number(WEAPON ID)Obtiene el número que contiene la party actual de una determinada arma
$game_party.weapon_number(WEAPON ID, PARTY ID)Obtiene el número que contiene una party de una determinada arma
$game_party.armor_number(ARMOR ID)Obtiene el número que contiene la party actual de un determinado protector
$game_party.armor_number(ARMOR ID, PARTY ID)Obtiene el número que contiene una party de un determinado protector
$game_party.gain_item(ITEM ID, NUMBER)Añadir un objeto a la party
$game_party.gain_item(ITEM ID, NUMBER, PARTY ID)Añadir un objeto a la party
$game_party.lose_item(ITEM ID, NUMBER)Quitar un objeto de la party
$game_party.lose_item(ITEM ID, NUMBER, PARTY ID)Quitar un objeto de la party
$game_party.move_item(ITEM ID, NUMBER, CURRENT PARTY ID, NEW PARTY ID)Mover un objeto de una party a otra
$game_party.gain_weapon(WEAPON ID, NUMBER)Añadir un arma a la party
$game_party.gain_weapon(WEAPON ID, NUMBER, PARTY ID)Añadir un arma a la party
$game_party.lose_weapon(WEAPON ID, NUMBER)Quitar un arma de la party
$game_party.lose_weapon(WEAPON ID, NUMBER, PARTY ID)Quitar un arma de la party
$game_party.move_weapon(WEAPON ID, NUMBER, CURRENT PARTY ID, NEW PARTY ID)Mover un arma de una party a otra
$game_party.gain_armor(ARMOR ID, NUMBER)Añadir un protector a la party
$game_party.gain_armor(ARMOR ID, NUMBER, PARTY ID)Añadir un protector a la party
$game_party.lose_armor(ARMOR ID, NUMBER)Quitar un protector de la party
$game_party.lose_armor(ARMOR ID, NUMBER, PARTY ID)Quitar un protector de la party
$game_party.move_armor(ARMOR ID, NUMBER, CURRENT PARTY ID, NEW PARTY ID)Mover un protector de una party a otra
$game_party.item_can_use?(ITEM ID)Comprobar si la party actual puede usar un item
$game_party.all_dead?Comprobar si todos los miembros de todas las parties están muertos
$game_party.all_dead?(PARTY ID)Comprobar si todos los miembros de una party están muertos
avatar
Wecoc
Administrador
Administrador



Créditos 9370

Gracias : 517

Volver arriba Ir abajo

RPG Maker XP Re: [XP] Multiple Game_Party IDs

Mensaje por Ledai el 2016-11-30, 13:16

O.O Un aporte muy interesante. Sin duda resultará práctico a más de uno. 
Aunque actualmente no lo voy a usar, pienso archivarlo para poder usarlo en algún otro proyecto lejano, pues siempre he considerado algo raro si el grupo se parte o se divide que se comparta base de datos e inventario, que incluso sucede en juegos comerciales y de consolas.
avatar
Ledai
Aventurero
Aventurero

0/3

Créditos 2815

Gracias : 174

Volver arriba Ir abajo

Ver el tema anterior Ver el tema siguiente Volver arriba


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