Hime's Synchronized Battlers - German Version

=begin
#===============================================================================
 Titel: Synchronized Battlers
 Autor: Hime
 Übersetzung: Puma
 Datum: Nov 13, 2013
 URL: http://himeworks.com/2013/11/10/synchronized-battlers/
--------------------------------------------------------------------------------
 ** Change log
 Nov 13, 2013
  - actor sync und link eingebaut
 Nov 12, 2013
  - sync link object eingeführt
  - "sync_death" hinzugefügt, wenn Gegner durch sync death sterben
 Nov 10, 2013
  - ursprünglicher release
--------------------------------------------------------------------------------
 ** Nutzungsbedingungen
 * Kostenlos für nicht-kommerzielle Projekte
 * Kontaktiert mich für kommerzielle Nutzung
 * Keine richtige Unterstützung. Das Skript wird so wie es ist zur Verfügung gestellt
 * Bugs werden behoben, aber keine Kompatibilitätsprobleme
 * Nach Features kann gefragt werden, aber es gibt keine Garantie, dass sie auch
   umgesetzt werden, besonders bei unnötigen Änderungen
 * Credits gehen in eurem Projekt an Hime Works
 * Dieser Teil muss erhalten bleiben
--------------------------------------------------------------------------------
 ** Beschreibung

 Dieses Skript erlaubt es euch, Monster aneinanderzuketten, oder zu "verbinden".
 Verbundene Monster können spezielle Eigenschaften miteinander teilen, die die
 regulären nicht haben.

 Verbindungen folgen einer Elternteil-Kind Beziehung. Stirbt der Elternteil, stirbt
 auch das Kind. Stirbt aber das Kind, passiert nichts mit dem Elternteil. Ihr könnt
 eine zweiseitige Beziehung erstellen, so das auch wenn das Kind fällt, beide Teile
 sterben.

 Angenommen, ihr habt eine Hydra, die aus drei Köpfen und einem Körper besteht. Wenn
 ihr einen Kopf tötet, sind die anderen Köpfe und der Körper nicht davon betroffen,
 tötet ihr aber den Körper, werden auch die ganzen Köpfe absterben. Der Körper der
 Hydra ist der Elternteil, jeder Kopf ein Kind.

--------------------------------------------------------------------------------
 ** Installation

 Platziert das Skript im Skripteditor unter Materials und über Main.

--------------------------------------------------------------------------------
 ** Nutzung

 -- Gegner verbinden --

 Um zwei Gegner zu verbinden, macht folgenden Script Call

   link_enemy(child_index, parent_index)
   link_enemy(child_index, parent_index, two_way)

 Wobei index immer der Reihenfolge der hinzugefügten Gegner entspricht. Ihr könnt
 diesen index auch sehen, indem ihr euch bei den "enemy battle" Event Commands wie
 "Change Enemy HP" die Liste anschaut. Der index steht vor dem Gegner Namen.

 `two_way` ist entweder true "wahr" oder false "falsch" und wird genutzt um eine
 Doppelbeziehung zwischen Elternteil und Kind herzustellen.

 -- Gegnerbindungen trennen --

 Um zwei Gegnerbindungen zu trennen, nutzt ihr folgenden Script Call

   unlink_enemy(child_index, parent_index)

 Das bricht jegliche Beziehung, auch wenn sie eine doppelte war.

 -- Actors "Helden" verbinden --

 Um zwei Gruppenmitglieder zu verbinden, nutzt ihr

   link_actor(child_index, parent_index)
   link_actor(child_index, parent_index, two_way)

 Wobei index entweder eine positive Zahl ist, die der actor ID entspricht,
 oder eine negative, die der Stellung im Kampf entspricht. Zum Beispiel
 würde ein index von 3 actor 3 in der Datenbank heißen, aber ein Index von
 -3 würde das Gruppenmitglied in der dritten Position treffen.

 -- Actorbindungen trennen --

 Um zwei Gruppenmitglieder zu trennen, könnt ihr folgenden Script Call benutzen

   unlink_actor(child_index, parent_index)

 -- Kämpfer verbinden --

 Ihr könnt sogar Gruppenmitglieder an Gegner oder umgekehrt binden. Diesmal
 müsst ihr aber im Gegensatz zu den vorherigen Calls Objekte nutzen.

 Es gibt zwei Methoden die es euch einfach machen:

   get_actor(index) - gibt ein Gruppenmitglied mit dem gegebenen Index aus
   get_enemy(index) - gibt einen Gegner mit dem gegebenen Index aus

 Die index-Regeln sind die gleichen wie zuvor. Habt ihr nun also einen Gegner
 und ein Gruppenmitglied, könnt ihr sie folgendermaßen verbinden

   actor = get_actor(-2)
   enemy = get_enemy(3)
   link_battler(actor, enemy)

 Das verbindet das Gruppenmitglied mit dem Gegner, wobei das Gruppenmitglied
 das Kind ist.

--------------------------------------------------------------------------------
 ** Beispiel

 Um das Hydra-Beispiel einzustellen, würdet ihr eine Truppe erstellen, die aus
 dem Körper der Hydra und drei ihrer Köpfe besteht. Nehmen wir an, der Körper
 hat den Index 1 und die Köpfe 2,3 und 4.

 Dann würdet ihr zu Beginn des Kampfes den folgenden Script Call machen

   link_enemy(2, 1)  # verbindet den ersten Kopf mit dem Körper
   link_enemy(3, 1)  # verbindet den zweiten Kopf mit dem Körper
   link_enemy(4, 1)  # verbindet den dritten Kopf mit dem Körper

 Stirbt nun der Körper, sterben alle drei Köpfe mit ihm.

#===============================================================================
=end
$imported = {} if $imported.nil?
$imported["TH_SynchronizedBattlers"] = true
#===============================================================================
# ** Rest des Skripts.
#===============================================================================
class Data_SyncLink

  attr_reader :parent
  attr_reader :child

  def initialize(parent, child, two_way=false)
    @parent = parent
    @child = child
    @two_way = two_way
  end

  #-----------------------------------------------------------------------------
  # Returns true if it's a two-way link.
  #-----------------------------------------------------------------------------
  def two_way?
    @two_way
  end
end

class Game_BattlerBase
  attr_reader :sync_check
  attr_accessor :sync_death
  attr_reader :sync_links

  alias :th_synchronized_battlers_initialize :initialize
  def initialize
    th_synchronized_battlers_initialize
    @sync_parent = nil
    clear_sync_links
    clear_sync_check
  end

  #-----------------------------------------------------------------------------
  # Hack workaround.
  #-----------------------------------------------------------------------------
  alias :th_sync_effects_refresh :refresh
  def refresh
    th_sync_effects_refresh
    perform_collapse_effect if dead?
  end

  def clear_sync_links
    @sync_links = []
  end

  def clear_sync_check
    @sync_check = false
  end

  def sync_battler?
    !@sync_links.empty?
  end

  def sync_death?
    @sync_death
  end

  def link_battler(battler, two_way)
    @sync_check = true
    syncLink = Data_SyncLink.new(self, battler, two_way)
    @sync_links.push(syncLink)
    battler.link_battler(self, two_way) if two_way && !battler.sync_check
    @sync_check = false
  end

  def unlink_battler(battler)
    @sync_check = true
    syncLink = @sync_links.find {|link| link.child == battler }
    if syncLink
      @sync_links.delete(syncLink)
      battler.unlink_battler(self) if syncLink.two_way? && !battler.sync_check
    end
    @sync_check = false
  end

  #-----------------------------------------------------------------------------
  #
  #-----------------------------------------------------------------------------
  def perform_sync_collapse(battler)
    battler.sync_death = true
    battler.hp = 0
    battler.perform_collapse_effect
  end
end

class Game_Enemy < Game_Battler

  alias :th_synchronized_battlers_perform_collapse_effect :perform_collapse_effect
  def perform_collapse_effect
    @sync_check = true
    th_synchronized_battlers_perform_collapse_effect
    @sync_links.each do |syncLink|
      battler = syncLink.child
      perform_sync_collapse(battler) unless battler.sync_check || battler.dead?
    end
    @sync_check = false
  end
end

class Game_Actor < Game_Battler

  alias :th_synchronized_battlers_perform_collapse_effect :perform_collapse_effect
  def perform_collapse_effect
    @sync_check = true
    th_synchronized_battlers_perform_collapse_effect
    @sync_links.each do |syncLink|
      battler = syncLink.child
      perform_sync_collapse(battler) unless battler.sync_check || battler.dead?
    end
    @sync_check = false
  end
end

class Game_Interpreter

  def get_enemy(index)
    return $game_troop.members[index-1]
  end

  def get_actor(index)
    if index < 0
      return $game_party.members[index * -1]
    else
      return $game_actors[index]
    end
  end

  #-----------------------------------------------------------------------------
  # Links a child enemy to another enemy
  #-----------------------------------------------------------------------------
  def link_enemy(child_index, parent_index, two_way=false)
    parent = get_enemy(parent_index)
    child = get_enemy(child_index)
    parent.link_battler(child, two_way)
  end

  def unlink_enemy(child_index, parent_index, two_way=false)
    parent = get_enemy(parent_index)
    child = get_enemy(child_index)
    parent.unlink_battler(child, two_way)
  end

  def link_actor(child_index, parent_index, two_way=false)
    parent = get_actor(parent_index)
    child = get_actor(child_index)
    parent.link_battler(child, two_way)
  end

  def unlink_actor(child_index, parent_index)
    parent = get_actor(parent_index)
    child = get_actor(child_index)
    parent.unlink_battler(child)
  end

  def link_battler(child, parent, two_way=false)
    parent.link_battler(child, two_way)
  end

  def unlink_battler(child, parent)
    parent.unlink_battler(child)
  end
end