Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- =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
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement