Persönliche Werkzeuge

Tower Defense Einsteiger Tutorial

Aus Starcraft II Map-Editor Wiki

Wechseln zu: Navigation, Suche

Tutorials > Einsteiger-Tutorials > Tower Defense Einsteiger Tutorial
geschrieben von mo93 und peq


Dieses Tutorial ist momentan noch im Aufbau, bitte habe noch etwas Geduld ;)


Inhaltsverzeichnis

Vorwort

Dieses Tutorial ist in Zusammenarbeit zwischen StarcraftMapping und inStarCraft entstanden, ihr findet das gleiche Tutorial ebenfalls unter http://starcraft2.ingame.de/content.php?c=102613 . Der Terrain und Daten-Editor Teil wurde von mo93 geschrieben, der Abschnitt über Trigger von peq.

In diesem Tutorial möchten wir euch erklären, wie ihr euch mit dem Starcraft2-Editor eine Tower Defense erstellt. Wir werden euch Schritt für Schritt alles beibringen, was ihr wissen müsst, damit diese funktioniert. Dieses Tutorial richtet sich also in erster Linie an Anfänger, die noch nicht viel Erfahrung mit dem Editor haben. Dieses Tutorial wird sich wenig in Details verlieben, sondern in erster Linie darlegen, wie man eine zweckdienliche Karte erstellt. Verschönerungen müssen – und sollen – nachträglich von euch selbst durchgeführt werden.

Wie ihr nachher mitbekommen werdet, wird hier der englische Editor benutzt. Die meisten Übersetzungen sind wortwörtlich, also solltet ihr keine großen Probleme haben, die hier beschriebenen Dinge auch im Deutschen Editor zu finden, es ist aber (zumindest im momentatenen Beta-Status) sehr empfehlenswert den englischen Editor zu verwenden.

Wir wünschen euch nun viel Spaß mit dem Tutorial. Solltet ihr während dem Tutorial auf Probleme stoßen, so könnt ihr Fragen im Hilfe-Forum oder im IRC-Chat stellen.

Terrain

Die Ausgestaltung des Terrains will ich hier nicht genau beschreiben. Allerdings werde ich euch einige Tipps geben, falls ihr euch selbst eines erstellen wollt. Hier seht ihr mein Terrain.

Terrain.png

Die Größe der Karte beträgt 104². Wenn wir vier Spieler wollen, werden wir wohl kaum eine geringere Größe benutzen können. Dann habe ich über Map -> Map Bounds den Rand an jeder Seite auf 10 verringert. Das sollte eigentlich reichen.

Die Ecken habe ich mit einem Pinsel der Größe 10 gemacht, die Wege mit Größe 4. An den Ecken werden die Creeps spawnen. Danach werden sie den Wegen in die Mitte folgen. Sobald sie die Mitte erreicht haben, verlieren die Spieler ein Leben. Sowohl an Ecken als auch an die Wege gibt es bestimmte Forderungen. Die Ecken müssen so groß sein, dass jeweils etwa 20 Einheiten gleichzeitig darin stehen können. Und die Wege müssen breit genug sein, dass die Einheiten durchlaufen können, ohne zu stucken. Das Gelbe, das ihr seht ist das Pathing. Wenn ihr „H“ drückt, bekommt ihr unten den pathing-manager. Dort wählt ihr das „no-building“-pathing und füllt die Lanes mit diesem aus. Damit verhindert ihr, dass die Spieler den Creeps den Weg blocken.

Besonders ausgereift ist das Terrain nicht, aber ich denke euch wird sicher etwas Gutes einfallen, wenn ihr ein wenig darüber nachdenkt. Aber wie gesagt soll diese Map in erster Linie zweckmäßig und nicht schön sein. Wenn ihr wollt könnt ihr noch Foliage hinzu fügen, aber das ist Geschmackssache.

Einheiten

Einleitung

Die Einheiten sind wohl der wichtigste Punkt neben der TD. Hier in diesem Teil des Tutorials werde ich euch erklären, wie ihr alle Einheiten erstellt, die ihr benötigt. Ich werde dabei auf den Baumeister, die Türme und die Feinde eingehen. Auch die Fähigkeiten dieser werden hier genau beschrieben und erläutert.

Ich will dies hier so erläutern, dass es danach einfach erweitert und weiter verwendet werden kann.

Der Data-Editor

Der Data-Editor von Starcraft2 ist ein enorm mächtiges, dadurch aber auch leider sehr kompliziertes Tool. Ihn zu benutzen erfordert einige Konzentration und etwas Wissen. Bei korrekter Benutzung kann man allerdings erstaunliche Ergebnisse mit ihm vollbringen, die mit dem Einheiten Editor von Warcraft3 noch undenkbar gewesen wären. Wichtiges Wissen über den Data Editor ist, dass alles modular aufgebaut ist. Das bedeutet, dass eine Einheit nicht nur einfach eine Einheit ist. Sie besteht aus einzelnen Modulen. Einem Modul für die Einheit allgemein, eines für den Angriff, mehrere für alle Effekte, die ein Angriff auslöst, Module für alle Fähigkeiten, Modelle, Sounds etc.

Aufrufen könnt ihr den Data-Editor über einen Druck der Taste F7. In dem folgenden Screen erkläre ich euch die wichtigsten Aspekte.


Der Daten-Editor

Wie ihr feststellen werdet, werde ich alle Module, die verändert werden kopieren. Das liegt daran, dass ich die originalen Einheiten unverändert lassen werde. Man könnte diese zwar überschreiben, aber das würde ich nach Möglichkeit nicht tun, da man sie eventuell noch braucht.

Der Worker

Die wichtigste Einheit beim TD ist und bleibt der Worker. Somit erstellen wir diesen als erstes. Dazu wählen wir das SCV der Terraner an. Dann klicken wir rechts und wählen per drop-down Menü „Duplicate Object“ an.

In dem folgenden Menü machen wir bei „Actor“ und bei „SCV – Build SCV“ ein Häkchen in den Kasten. Was habe ich gerade gemacht? : Ich habe in der letzen Aktion eine Kopie vom SCV erstellt. Damit nun jedoch nicht jede Fähigkeit wie „Move“, „Attack“ etc neu kopiert wird, habe ich nur den Actor erstellt. Den Angriff habe ich nicht kopiert, da wir diesen eh nicht modifizieren werden. Die Fähigkeit habe ich ebenfalls dupliziert, da hier festgelegt wird, was unsere Einheit bauen kann. Die Fähigkeit zu Bauen muss dupliziert werden, da sie modifiziert wird und somit auch das SCV dann andere Einheiten bauen will.

Fähigkeiten wie „move“ und „Attack“ sind dagegen bei allen Einheiten gleich, deswegen bleiben sie unverändert und wir müssen sie nicht duplizieren. Als nächstes wählen wir die Einheit selbst an und gehen in das Feld „Stats – name“ und geben den Namen für unseren Worker ein. Ich nenne ihn hier einfach „Worker“ Danach wählen wir bei „stats – flags“ invulnerable an, damit unser Worker nicht angegriffen werden kann. Da er aber immer noch Splash Damage bekommt, setzen wir seine Lebensregeneration am besten auf einen hohen Wert. Wir wählen also „Stats – Life Regeneration Rate“ und setzen diese auf 1000. „Movement – Speed“ erhöhen wir, damit unser Worker schneller fährt. Ich habe ihn auf 5 gesetzt. „Movement – Acceleration“ setzen wir auf 1000, damit unser Worker sofort auf Höchstgeschwindigkeit ist und nicht erst lange Beschleunigen muss. Den „Movement-Mover“ setzen wir auf „Fly“ und den „Movement – Plane Array“ auf „Air“ und danach noch „Stats – collide“ auf „flying“, damit unser Worker über die Lanes drüber fliegen kann. Ground wählen wir dabei jeweils ab.

Als nächstes entfernen wir die Fähigkeit, des „advanced build“, da wir diese nicht mehr brauchen. Dazu gehen wir auf den Worker. Wählen „(None) – Command Card +“ Dann klicken wir auf den Button für Build Advanced Structure (Terran). Dieser befindet sich in der untersten Reihe und ist der zweite von Links. Wenn wir ihn markiert haben, gehen wir darunter bei Buttons auf das rote kreuz und klicken darauf. Danach ist der Button nicht mehr zu sehen, wenn wir den Worker angewählt haben. Nun wählen wir die Fähigkeit „SCV – Build (SCV) copy“ an und doppelklicken darauf. In dem sich öffnenden Fenster ändern wir den Namen in „Build (Worker)“. Danach gehen wir in dem rechten Fenster auf den Punkt „(none) – Editor Prefix“ und geben „Worker – „ ein. Auch den Actor benennen wir in „Worker“ um.

Das ganze erfüllt den praktischen Zweck der Übersichtlichkeit. Falls ich zum Beispiel das SCV fünf mal duplizieren würde hätte ich danach die Actors „SCV Copy“, „SCV Copy2“, „SCV Copy3“ etc. Um das zu verhindern ändern wir die Namen immer.

Die Fähigkeit des Workers, Gebäude zu bauen werden wir erst am Ende bearbeiten, wenn wir alle Türme haben.

Türme

Die Phase-Cannon

Der erste Turm, den wir erstellen ist die Phase-Cannon. Dazu suchen wir uns unter „Melee-Protoss-structures“ die Photon-Cannon und duplizieren sie. Diesmal machen wir ein Häkchen bei den Actors „Photon Cannon“ und „Photon Cannon Splat“, die beiden Effects „Phase Cannon – Photon Cannon (Damage)“ und „Phase Cannon – Photon Cannon (Launch Missile)“ und bei der Weapon „Phase Cannon – Photon Cannon“. Den Rest lassen wir unausgewählt, da er auch unverändert bleiben kann. Als erstes ändern wir bei unserer Einheit den Namen. Genau wie bei dem Worker wählen wir „Unit – Name“ an und geben „Phase Cannon“ ein. Bei „Unit – Flags“ wählen wir wieder „invulnerable“ an

Danach gehen wir auf „Behavior– Behaviors +“ . In dem sich öffnenden Fenster wählen wir „Power User (Queue, Base defense)“ aus und klicken auf das kleine rote Kreuz daneben. Wenn wir das getan haben, benötigt unser Turm keinen Pylonen mehr in der Nähe um gebaut zu werden und zu funktionieren. Wir gehen nun in dem oberen linken Feld aus dem Feld „units“ in das Feld „actors“ und von dort nach „Action – Generic Attack – Not Doodad – Photon Cannon Attack“ und duplizieren diesen, lassen aber alles so, wie es ist.

Auch diesen Actor benennen wir um in „Phase Cannon Attack“ In dem oben abgegrenzten Bereich verändern wir den Wert bei „Impact Effect“ zu dem Effekt „Phase Cannon – Photon Cannon(Damage) Copy“, also dem Damage-effect, den wir für unsere Phase Cannon dupliziert haben. Den „Launch-Effect“ ändern wir auf die gleiche Weise. Nun erzeugt unser Turm beim Schießen auch Geräusche. Als nächstes verändern wir die Waffe unserer Phase Cannon. Wir wollen, dass sie schneller und weiter schießt, dafür aber ein bisschen weniger Schaden macht. Als erstes wählen wir dazu die Waffe „Phase Cannon – Photon Cannon copy“ an. Dort gehen wir in das Feld „Stats – Period“ und setzen diesen auf eins. Dieser Wert gibt an, wie viel zeit zwischen zwei Angriffen liegt. Nun also genau eine Sekunde.

Danach wählen wir „Stats – range“ an und verändern hier die Reichweite des Turms auf 8. Um noch den Schaden zu verändern gehen wir auf den Effect „Phase Cannon – Photon Cannon (damage) copy“. Dort wählen wir das Feld „Combat – amount“ aus und setzen den Wert auf 15. Damit macht unser Turm bei jedem Schuss nur noch 15 Schaden. Wir benennen allerdings die beiden Actors, Effekte und die Weapon um, wie bei unserem Worker beschrieben. Dann wären wir mit dem Turm an sich schon fertig und er ist einsatzbereit für den Kampf.

Turbo-Phaser

Der nächste Turm wird der Turbo-Phaser. Dieser ist ein Upgrade der Phase Cannon und verfügt über erhöhte Reichweite und Schussgeschwindigkeit. Wir duplizieren uns also wie eben die Photon Cannon, dieses mal aber keinen Actor. Dieser kommt danach. Danach machen wir den Tower unverwundbar. Auch hier löschen wird das Behavoir „power user“. Aber nun gehen wir auf den Reiter „Actors“ und wählen dort „Unit – GenericUnitStandard – Not Doodad –Fleet Beacon“ und duplizieren uns diesen, lassen aber alles unangewählt. Auch diesen Actor benennen wir um.

Danach gehen wir bei unserem Actor im oberen, rechten Feld auf „unitName“ und wählen dort unseren Turbo Phaser aus. Danach müssen wir bei „Art – Model“ als Modell „Fleet Beacon“ auswählen. Bei „Art – Scale“ ändern wir alle Werte auf 0.6. Dadurch wird unser Model auf 60% der Originalgröße verkleinert.

Die Reichweite unserer Waffe erhöhen wir auf 11, die Period verringern wir auf 0.2

Storm Tower

Unser nächster Turm soll ein AOE Turm werden. Allerdings nicht einfach einer mit Splash-Angriff. Nein, er wird als Angriffseffekt den Psi Sturm des Hohen Templers kriegen. Was sich zu Anfang recht schwer anhört, ist in Wirklichkeit dank des modularen Aufbaus enorm einfach. Dazu benutzen wir als Ausgangsmodel den Pylonen. Wir duplizieren die beiden Actors „Pylon“ und „Pylon – Splat“ Wieder benennen wir alles um. Auch diesen Turm machen wir unverwundbar. Danach gehen wir auf den Reiter Effects und geben in die Suchleiste „Psi Storm“ ein. Dort wählen wir den Effect „High Templar – Psi Storm (Persistent)“ und duplizieren ihn. Dabei duplizieren wir die Actors, das Behavior, und alle Effects. Auch hier sollten wir alles umbenennen in „Storm Tower – Psi Storm …“

Um das richtige einzustellen, müssen wir verstehen, wie der Psi Sturm funktioniert. Am Anfang wird durch einen Angriff der Effect „Psi Storm(Persistent)“ ausgelöst. Dieser wird dann so oft ausgelöst, wie in „Period“ steht. Und jedesmal löst er den Effect „Psi Storm(Search)“ aus. Dieser sucht sich alle Einheiten in einem bestimmten Radius und legt auf diese den Effect „Psi Storm (Apply Buff)“. Dieser Effect wiederrum hat das Behavior „Psionic Storm“ Und dieses Behavior wiederrum löst dann den Schaden aus. Klingt relativ komplex, ist aber wohl eine relativ praktische Lösung, da man hiermit enorm flexibel ist.

Als nächstes müssen wir den Psi Storm an unsere Bedürfnisse anpassen. Wir wollen, dass der Umkreis größer wird, und er etwas kürzer dauert, wobei der Schaden per Sekunde erhöht wird. Dazu gehen wir auf „Storm Tower – Psi Storm(Search)“ und wählen dort „Search – Areas“+. In dem sich öffnenden Fenster gehen wählen wir in dem oberen Fenster den einzigen Eintrag und ändern dann den Wert in „Radius“ auf 2. Damit ist der Umkreis in dem unser Psi Storm Schaden anrichtet erhöht. Danach gehen wir auf den Effect „Storm Tower – Psi Storm (Persistent)“ wählen „Effect – Period Count“ und ändern den Wert in 11(Sc2 fängt bei 0 an zu zählen). Danach gehen wir auf „Effect – Durations“ und ändern den Wert auf 0.25. Somit wird öfter und in kürzerem Abstand der Effect ausgelöst.

Danach gehen wir auf den Effect „Storm Tower – Psi Storm (Damage2)“ und ändern den Wert „Combat – Amount“ auf 0. Ansonsten würde zuviel Schaden entstehen. Als nächstes wählen wir das Behavior „Storm Tower – Psi Storm“. Dort ändern wir „Stats – Duration“ und Stats – Period“ jeweils in 0.25. Da der Schaden nicht stackt und über einen gewissen Zeitraum verursacht wird, würden sonst mehrmals der Schaden nicht entstehen, da die Einheit den Buff für den Schaden schon hat. Das ist hiermit behoben. Nun wird 12 mal alle 0,25 Sekunden der Psi Storm effect ausgeführt und alle Einheiten im Radius von 2 bekommen 10 Schaden.

Damit der Turm sich nachher beim Schießen auch drehen kann erstellen wir ein Turret. Dazu wählen wir im Reiter „Turrets“ das Turret der Photon Cannon und duplizieren es zusammen mit dem Actor. Natürlich benennen wir auch das hier wieder um. Dann wählen wir den Wert „Idle“ des Turrets und ändern es in Spin. Damit dreht sich unser Turm, solange er nichts zu tun hat. Letzteres ist Geschmackssache, und gefällt wohl nicht jedem. Danach kopieren wir uns eine Waffe. Prinzipiell ist es relativ egal, da wir die Werte eh ändern werden. Deswegen müssen wir auch keine Effects und die Unit nicht kopieren. Ich benutze jetzt hier die Waffe der Photonen Kanone und benenne sie danach in „Weapon – Storm Tower“ um. Die Reichweite ändere ich auf 10, die Periode auf 3. Als UI – Damage Display Effect wählen wir „Storm Tower – Psi Storm (Damage)“. Wobei das hier relativ egal ist, da unser Turm seinen Schaden eh anders anrichtet, als durch Standardangriff. Als „Effect – Effect“ wählen wir „Storm Tower – Psi Storm (Persistent)“

Als nächstes erstellen wir uns einen Button, der den User darauf hinweist, dass diese Einheit einen Psi Sturm Angriff hat. Wir benutzen als Basis den „High Templar – Psionic Storm“ Button. Wir ändern den Namen in „Storm Tower – Psi Storm“ und den „Alert Tooltip“ in „This Tower creates a mighty Psi Storm with every Attack. This Storm will deal 120 Damage over 3 Seconds to all units in the area. <c val="FF0000">Damage Effect does not Stack.</c>“ Das „Damage Effect does not Stack“ befindet sich innerhalb eines Farbcodes und wird im Spiel rot dargestellt. Nun gehen wir wieder auf die Einheit „Storm Tower“ und dort auf „Combat – Weapons+“ . In dem sich öffnenden Fenster sind bereits zwei Turrets angegeben. Diese sind dafür da, dass sich bestimmte Teile des Turms drehen. Mit dem kleinen grünen X fügen wir eine Waffe hinzu. Wir wählen als Waffe die neu erstellte Waffe und als Turret das neu erstellte Turret. Unter „Behavior – Behaviors+“ löschen wir den Wert. „Power Source“

Danach gehen wir auf „Ability – Command Card+“ Dort erstellen wir drei Buttons. Als erstes im oberen linken Eck einen für Stopp. Dazu klicken wir auf das leere Feld in dieser Ecke und gehen auf das kleine grüne X. Wir wählen in dem sich öffnenden Fenster den Button „Stop“. Dann klicken wir auf OK. Dann wählen wir unter „Command Type“ „Ability Command“ aus und als Ability „Selection – Stop“. Der nächste Button wird der für Attack sein. Dazu gehen wir auf das rechte obere Eck und widerholen das gleiche wie vorher. Nur dass wir diesmal den Button „Attack (Building)“ auswählen und als „Ability“ wählen wir „Attack“. Nun noch der Button für den Psi Storm. Dazu gehen wir auf ein Feld, das noch leer ist und erstellen wieder einen neuen Button. Wir wählen dazu den neu erstellen Button aus. Und wählen als „Command Type“ „Passive“. Danach klicken wir auf OK. Damit wäre unser Turm auch schon fertig und testbereit.

Der Spore-Thrower

Als nächsten Turm werden wir den Spore Thrower einbauen. Dieser basiert auf dem Spore Crawler. Allerdings wird er feindliche Einheiten, die er trifft verlangsamen. Als erstes duplizieren wir also den Spore Crawler. Wir duplizieren die Weapon, die Effects und den Actor „Spore Crawler“

Wieder benennen wir alles um. Den Angriff habe ich „Spore-Thrower – Slowing Spores“ genannt. Beim Spore Thrower löschen wir das Behavoir „Zerg – Building Not On Creep“ Unter „Ability – Abilities+“ löschen wir die Fähigkeit „Spore Crawler – Uproot“ Danach gehen wir auf die Commandcard unter „Ability– Command Card+“ wir löschen den Button für „uproot“.

Danach machen wir auch diesen Turm unverwundbar. Bei der Weapon unseres Spore Throwers ändern wir die Reichweite zu 10 und die Period zu 1.5 Danach gehen wir auf „Weapon – Target Filters“. In dem sich öffnenden Fenster machen wir zwei Doppelklicks auf Air, damit sich der Wert auf „Allowed“ ändert. Nun können auch Bodeneinheiten attackiert werden.

Danach gehen wir in den Reiter „Effects“ und geben in die Suchleiste Marauder ein. Wir duplizieren uns hier die zwei Effects „Marauder – Concussive Grenade (set)“ und „Marauder – Concussive Grenade (Slow)“, lassen aber jeweils alles unmarkiert. Auch diese beiden effects benennen wir um. In dem Effect „Marauder – Concussive Grenade(Slow)“ ist schon alles voreingestellt, was wir für den Slow an sich brauchen, während der Effect „Marauder – Concussive Grenade (set)“ es uns erlaubt, diesen Slow mit dem Angriff zu verbinden. Wir wählen nun den Effect „Spore Thrower – Slowing Spores (Set)“ und gehen in das Feld „Effects – Effects“ Hier geben wir nun die beiden Effects „Spore Thrower – Slowing Spores (Slow)“ und „Spore Thrower – Spore Thrower (Damage)“ ein.

Danach wechseln wir wieder zurück in den Reiter „Einheiten“, gehen auf unseren Spine-Basher und wählen den Effect „Spore Thrower – Spore Thrower (Launch Missile)“ aus. Dort gehen wir auf „Art – Impact Effect“ und wählen dort „Spore Thrower – Slowing Spores (Set)“ aus. Nun sollte alles stimmen, nur dass der Slow im Moment noch eine Bedingung hat, nämlich dass Punisher Grenades erforscht wurden. Das müssen wir noch ändern. Dazu gehen wir auf „Spore Thrower – Slowing Spores (Slow)“ und danach auf „Effect – Validators“. Hier werden alle Bedingungen angegeben die erfüllt sein müssen, damit der Slow auch funktioniert. Wir wählen die Bedingung „Marauder – Punisher Grenades Researched“ aus und löschen sie. Nun verändern wir noch bei „Spore Thrower – Spore Thrower (Damage)“ den Schaden auf 45 Danach gehen wir auf den Reiter Actors und fügen die Actors für die Effects hinzu, damit Sounds etc beim Angriff stimmen. Als erstes gehen wir auf „Action – GenericAttack – Not Doodad – Spore Crawler Attack“ Diesen duplizieren wir und benennen ihn um. Den Impact Effect ändern wir zu „Spore Thrower – Spore Thrower (Damage)” , den Launch Effect ändern wir in „Spore Thrower – Spore Thrower(Missile)“

Als letztes müssen wir noch einen Button hinzufügen, damit man auch sieht, dass unser Turm feindliche Einheiten verlangsamen kann. Dazu gehen wir in den Reiter „Buttons“ Dort suchen wir uns irgendeinen Button aus, der uns gefällt und duplizieren ihn. Wir ändern den Namen in „Slowing Attack“ und das „Editor Prefix“ in „Spore Thrower - “ den „Alert Tooltip“ ändern wir auf „The Spores oft he Spore Thrower are poisoined and so will slow enemy units by attack.”Danach fügen wir in die Commandcard des Spine Bashers noch einen button hinzu. Dazu gehen wir beim Spine Basher auf „(None) – Command Card + „ und klicken auf ein freies Feld. Danach klicken wir auf das grüne X. In dem sich öffnenden Fenster wählen wir den gerade eben erstellten Button aus und klicken „ok“. Danach wählen wir als Command Type „Passive“ aus und lassen die beiden anderen Felder auf „None“ Und schon ist unser Turm fertig.


Der Rocket-Launcher

Nun brauchen wir noch einen Aoe Turm. Dieser wird allerdings nicht einmal schießen, sondern immer 8 Schüsse in Folge abgeben, bevor er kurz nachlädt. Dazu nehmen wir als Basis das Missile-Turret der Terraner. Also gehen wir auf diesen Turm und duplizieren ihn uns. Wir duplizieren uns den „Missile Turret“ Actor, die drei effects und die Weapon.

Als erstes benennen wir alles um., dann machen wir den Turm unverwundbar. Den Angriff nenne ich „Cluster Missiles“. Das ist zwar nicht ganz korrekt, aber es hört sich nicht schlecht an. Danach duplizieren wir uns die Actors der Effects. Unser Turm wird nur alle 2 Sekunden angreifen, und eine Reichweite von 10 haben. Auch hier müssen wir bei dem Angriff wieder den Angriff von Bodeneinheiten erlauben. Bei „UI – Display Attack Count“ geben wir 8 an. Um die Anzahl der Angriffe zu verändern gehen wir auf den Effect „Rocket Launcher – Cluster Missiles (Persistent)“ und dort auf „Effect – Period Count“ Bei „Effect – Period Durations“ fügen wir sechsmal zusätzlich „0.1“ ein. Danach gehen wir auf den Effect „Rocket Launcher – Cluster Missiles (Damage)“. Dort ändern wir den Schaden auf 25.

Den Splash Damage könnten wir auch von Hand Einstellen, allerdings werde ich ihn mir hier vom Siege Tank kopieren. Wir gehen also auf den „Siege Tank(Siege mode)“ und wählen dort dessen Schadenseffekt. Bei diesem klicken wir rechts auf das Feld „Search – Area+“ und wählen Copy. Danach gehen wir zurück zu unserem Rocket Launcher, klicken dort bei unserem Schadenseffekt ebenfalls rechts, wählen diesmal aber „paste“. Danach gehen wir auf das Feld „Search – Exclude+“, direkt darunter und wählen es aus. In dem sich öffnenden Fenster klicken wir auf das grüne X und wählen als „Value“ „Target“ aus. Damit verhindern wir, dass das Ziel des Turms zweimal Schaden kriegt (Einmal durch den Angriff und einmal durch den Splash).

Somit wäre auch dieser Turm fertig.

Der Command-Tower

Unser letzter Turm wird ein Support Tower. Er soll den Schaden aller Türme in seiner Umgebung um 15% erhöhen.

Dazu benutzen wir als Basis den Sensor Tower der Terraner. Wir duplizieren ihn also, kopieren allerdings nur den Actor „Sensor Tower“ Danach benennen wir ihn in „Command Tower“ um und machen ihn unverwundbar. Wir löschen das Behavior „Sensor Tower – Radar“. Danach gehen wir in den Reiter „Behavoirs“ und wählen dort „Protoss – Buff – Mothership – Cloak Field“ und duplizieren diesen. Wir duplizieren uns dabei das Behavior und beide Effects mit. Danach benennen wir es um in „Command Tower – Damage Aura“ Wie genau funktioniert nun diese Aura? Das Behavior „Mothership – Cloak Field“ geben wir der Einheit. Dieses löst dann den Effect „Mothership – Cloaking Field Search“ aus. Dieser wählt alle Einheiten in der Umgebung und gibt ihnen den Effect „Mothership – Cloaking Field“ Dieser Effekt wiederrum löst dann das Behavoir „Mothership – Cloaking Field Effect“ aus. In diesem steht, dass die Einheit, die das Behavoir hat unsichtbar werden soll.

Wir lassen erst einmal alles unverändert, bis auf das letzte Behavior. Wir wählen also „Command Tower – Damage Aura Effect“ aus. Dort gehen wir auf „Behavior – Modification +“. Dort steht alles, was wir wissen wollen. Wir gehen in den zweiten Reiter und scrollen ganz nach unten, bis wir bei „State Flags“ sind. Dort wählen wir „Cloak“ und verändern den Wert auf Disabled. Danach gehen wir auf den Reiter „Combat“. Dort wählen wir bei „Damage Dealt (Scaled)“ den Wert „Ranged“ und verändern ihn auf 0.15. Danach schließen wir das Fenster. Wir wechseln zu den Einheiten zurück und geben unserem Turm unter „Behavior – Behaviors +“ das Behavior „Command Tower – Damage Aura“

Danach müssen wir noch einen Button erzeugen und dem Turm geben, der den User darauf hinweist, dass dieser Turm eine Schadensaura hat. Als letztes erzeugen wir einen weiteren Buff, gehen auf unseren „Command Tower – Damage Aura Effect“. Dort wählen wir „UI – Icon“ und wählen in dort aus. Dies ist nun der Buff, der bei allen Einheiten, die den erhöhten Schaden haben, angezeigt wird.

Die Bau-Fähigkeit

Als nächstes kommt die Fähigkeit unseres Bauarbeiters, die Türme zu bauen. Als erste benötigen wir einen Button für den Turm, den wir bauen wollen. Also wechseln wir in den Reiter mit den Buttons und erstellen uns dort einen neuen. Als Namen geben wir „Build Spore Thrower“ ein. Als Icon wählen wir den „Spore Crawler“.

Nun fehlt noch der Tooltip. Hier geben wir eine kurze Beschreibung des Turmes ein, die dann angezeigt wird, wenn der Spieler mit seinem Mauszeiger über den Button geht. Ein Beispiel für eine Beschreibung wäre: „The Spore Thrower is a tower, which throws poisonous spores at your enemy. If an Enemy gets hit, he will be slowed.“ Dabei ist zu beachten, dass wir die Kosten nicht selbst schreiben müssen, da Starcraft2 sie automatisch einfügt.

Dazu gehen wir auf den Reiter Fähigkeiten und suchen dort die Fähigkeit „Worker – Worker Build“ Dort gehen wir auf „Ability – Info+“. In dem sich öffnenden Fenster sehen wir nun alle Gebäude, die gebaut werden können mit den dazugehörigen Buttons. Wir doppelklicken auf „Command Center“. Nun haben wir ein Fenster, in dem sich alle relevanten Werte zum Bauen eines Turmes befinden. Wir wählen nun also bei „Default – Button“ auf unseren gerade eben erstellten button. Danach scrollen wir nach unten, bis wir „Resource“ finden. Dort ändern wir den Wert für Minerals auf 30. Danach scrollen wir bis nach ganz unten. Den Wert von „Unit“ ändern wir auf unseren Spore Crawler. In dem Wert „Time“ müssen wir eingeben, wie lange es dauert das Gebäude zu bauen. Da wir wollen, dass unser Gebäude nur eine Sekunde dauert, wählen wir dort den Wert 1.

Genauso wie mit dem Spore Crawler gehen wir auch bei den anderen Türmen vor. Die Kosten sind wie folgt:

  • Phase Cannon: 10 Minerals
  • Storm Tower: 60 Minerals
  • Rocket Launcher: 100 Minerals
  • Command Tower: 50 Minerals

Hier ist zu beachten, dass der Turbo Phaser nicht vom Worker gebaut wird, sondern ein upgrade der Phase Cannon ist, das heißt, bei ihm müssen wir anders vorgehen. Danach gehen wir wieder zu unserem Worker. Dort löschen wir in der Command Card die Buttons für „Repair“, „Gather“, „Return Cargo“, „Build Structure“ und „Build Advanced Structure“. Danach fügen wir die einzelnen Buttons für unsere Türme hinzu. Wichtig: Da das hinzufügen von selbsterstellen Gebäuden in Sub-Command-Cards nicht funktioniert, bzw Änderungen benötigt, die ich nicht kenne, müssen die Buttons für die einzelnen Tower direkt in die Haupt-Command-Card gestellt werden, wobei wir als Einstellung jeweils bei Command Type „Ability Command“ wählen und den Rest jeweils auf leer lassen.


Upgrade eines Turmes

Nun kommt noch das Upgrade der Phase Cannon zum Turbo Phaser. Hier erstellen wir uns eine Kopie der Fähigkeit „Command Center - Morph Building (COCE -> Orbital Command)“ , wobei wir alles unausgewählt lassen. Diese nennen wir „Upgrade to Turbo Phaser“. Dann wählen wir „Ability – Info+“ aus und machen einen Doppelklick auf „Orbital Command“ Hier können wir die ganzen Werte festlegen, die mit dem Upgrade zu tun haben, jedoch nicht die Kosten. Unter Durations verringern wir alle Werte, die im Moment auf 35 sind auf 1. Damit ist die Bauzeit auf eine Sekunde gesunken. Danach gehen wir auf „Cost – Cost+“ . Hier können wir die Kosten für das Upgraden festlegen. Wir scrollen bis zu „Resource“ nach unten. Hier wählen wir bei „Minerals“ 30 aus, damit unser Upgrade 30 Mineralien kostet.

Danach müssen wir den Actor unseres Turbo Phasers noch so einstellen, dass er auch angezeigt wird, wenn unser Turm upgegradet wird. Dazu gehen wir auf den Actor und dort auf „Event – Events+“ Dort erstellen wir per rechtsklick ein neues Event. Als „Msg Type“ wählen wir „Ability Morph“ aus. „Source Name“ lassen wir frei. Als „Sub Name“ verwenden wir „Finish“ Danach fügen wir einen neuen Term ein. Ebenfalls per Rechtsklick. Als „Term Type“ wählen wir „Morph From“ Als Unit Link wählen wir unseren Phase Tower.

Danach fügen wir noch einen zweiten Term hinzu. Hier wählen wir allerdings „Morph To“ und als Einheit wählen wir „Turbo Phaser“ Dann wählen wir den Term „Action Impact“ und ändern „Msg Type“ in „Create“ Als letztes müssen wir noch das Upgrade zu unserer Phase Cannon hinzufügen. Dazu gehen wir auf die Command Card, fügen einen Button für das Upgrade hinzu, wählen als Command Type „Ability Command“ aus.

Danach fügen wir noch die Fähigkeit hinzu, und das Upgrade ist fertig.


Trigger

In diesem Kapitel werden wir uns nun damit beschäftigen, wie man automatisch Einheiten erstellen kann, die dann zum Ziel laufen und falls sie dort ankommen die Leben der Spieler um 1 verringern. Für so etwas benötigt man Trigger, denn dies ist der Teil der Map, der alle Abläufe und damit quasi die "Spielregeln" bestimmt. Was genau Trigger sind, werdet ihr gleich erfahren.

Planung der Trigger

Bevor man den Trigger-Editor startet und wild drauf los "triggert" sollte man sich jedoch erst einmal Gedanken machen, was wir für unsere Turm-Verteidigung alles brauchen. Hier hilft es auf jeden Fall, wenn man sich die Anforderungen an die Map erst einmal aufschreibt um eine Basis zu haben, von der aus man sich strukturiert und organisiert zum Ziel vorarbeiten kann. Bei unserer TD lassen sich folgende Ziele identifizieren.

1. Einheiten-Erstellung

Zu Beginn des Spiels soll ein Countdown-Timer starten, der darauf hinweist, wann die erste Gegnerwelle startet. Sobald der Timer abgelaufen ist, sollen an allen Creep-Startpunkten eine bestimmte Anzahl Einheiten eines bestimmten Typs erstellt werden und zum Ziel laufen. Gleichzeitig soll ein Countdown-Timer starten, der den Beginn der nächsten Runde anzeigt. Wenn dieser abgelaufen ist startet die zweite Gegner-Welle mit einem anderen Einheiten-Typ und eventuell auch einer anderen Anzahl von Gegnern (insgesamt sollte die Welle natürlich stärker sein als die davor). Unter dem Countdown-Timer soll immer angezeigt werden um welche Gegner es sich bei der nächsten Welle handelt.

2. Gegner erreicht Ziel

Wenn eine gegnerische Einheit das Ziel erreicht, soll die Einheit mit einem Effekt verschwinden. Gleichzeitig soll die Anzahl der Leben für die Spieler um 1 verringert werden (die Spieler spielen im Team und teilen sich die Leben). Sind die Leben bei 0, so haben alle Spieler verloren.

3. Gegner wird getötet

Wenn ein Gegner getötet wird, erhält der Spieler, der diese Einheit getötet hat eine bestimmte Menge Geld (dies ist auch per Daten-Editor möglich) und die Kills dieses Spielers werden um 1 erhöht. Die Anzahl der Kills wird in einer Tabelle am rechten Bildschirmrand für alle Spieler angezeigt.

4. Spiel gewonnen

Wenn es keine weitere Gegnerwelle mehr gibt und alle Einheiten getötet worden, haben die Spieler die Karte gewonnen.


Diese vier Funktionen reichen für eine einfache TD aus. Bei größeren, komplizierteren Karten kommen natürlich noch mehr Funktionen hinzu. Hat man diese groben Ziele identifiziert kann man diese in kleinere Teile herunterbrechen, bis man kleine handliche (und oft auch wiederverwendbare) Stücke hat. Dies werden wir nach einer kurzen Einführung in das Trigger-Konzept auch tun.

Theorie: Das Trigger-Konzept

Dieses Kapitel soll zuerst einen kurzen Einblick in die Theorie hinter dem Trigger-Editor geben. Wie man selbst einen Trigger zusammenbaut wird im nächsten Kapitel behandelt.

Die Aufgabe von Triggern (deutsch: Auslöser) ist es, auf Ereignisse zu reagiern und dann bestimmte Aktionen auszuführen. In den Aktionen hat man die Möglichkeit Fallunterscheidungen einzubauen und so je nachdem, welcher Fall eintritt, andere Aktionen auszuführen. Ein Beispiel hierfür ist zum Beispiel das Leben der Spieler. Wenn wir dieses verringern (weil ein Gegner das Ziel erreicht hat) treten 2 Fälle auf: Entweder sind noch Leben übrig, dann passiert nichts besonderes, oder es sind keine Leben mehr übrig und die Spieler haben verloren. Im Trigger sieht das dann später etwa so aus:

Variable - Set Leben = (Leben - 1)

General - If (Conditions) then do (Actions) else do (Actions)
If
Leben > 0
Then
------- Noch genug Leben übrig
Else
------- Keine Leben mehr übrig -> Niederlage
Game - End game in Defeat for player 1 (Show dialogs, Show score screen)

Die Zeilen, welche mit ------ beginnen sind Kommentare und helfen euch und anderen den Überblick zu behalten. Mit Kommentaren sollte man nie sparen ;) Den Rest der Aktionen (und wie man sich solche Konstrukte überhaupt zusammen klickt) werden wir gleich noch genauer betrachten, man sollte aber schon durch einfaches lesen erkennen können, dass zuerst die Leben um 1 verringert werden, und dann eine Fall-Unterscheidung gemacht wird, ob das Leben Größer als 0 ist oder nicht.

Jeder Trigger hat standardmäßig eine Fallunterscheidung, die Bedingungen (Conditions) des Triggers. Hier kann man vor allen Aktionen entscheiden, ob überhaupt etwas passieren soll. Das macht Trigger in der Regel Übersichtlicher.

Ein weiteres wichtiges Element in den Aktionen sind Schleifen. Schleifen dienen dazu, Aktionen mehrmals auszuführen. Im Beispiel oben verliert nur Spieler 1. Wenn wir wollen, dass alle Spieler verlieren, benutzt man am besten eine Schleife, die alle Spieler auswählt. Das sieht dann so aus:

Player Group - Pick each player in (All players) and do (Actions)

Actions
Game - End game in Defeat for player (Picked player) (Show dialogs, Show score screen)

Das dritte wichtige Konzept, welches in diesem Abschnitt behandelt wird sind Variablen. Variablen verwendet man um Dinge zu speichern. Im ersten Beispiel haben wir schon gesehen, für was man Variablen gebrauchen kann. Dort haben wir die Variable "Leben" verwendet, um uns zu merken, wie viele Leben die Spieler noch haben. Bei Variablen muss man noch zwischen lokalen Variablen (gelten nur, bis alle Aktionen des Triggers abgelaufen sind und werden danach gelöscht) und globalen Variablen (sind dauerhaft) unterscheiden.

Zum Abschluss des Theorie-Teils betrachten wir noch einen vollständigen Trigger:

Gegner erreicht Ziel

Events
Unit - Any Unit Enters Ziel
Local Variables
Conditions
------- Der Besitzer der Einheit ist Spieler 11 (dem gehören die Creeps)
(Owner of (Triggering unit)) == 11
Actions
------- Leben eins runter zählen:
Variable - Set Leben = (Leben - 1)
General - If (Conditions) then do (Actions) else do (Actions)
If
Leben > 0
Then
------- Noch genug Leben übrig
Else
------- Keine Leben mehr übrig -> Niederlage
Player Group - Pick each player in (All players) and do (Actions)
Actions
Game - End game in Defeat for player (Picked player) (Show dialogs, Show score screen)

Dieser Auslöser erfüllt schon einige der Funktionen unserer dritten Anforderung. Versucht diesen Trigger zu lesen und zu verstehen was dabei passiert. Wie man so einen Trigger selbst baut, behandeln wir im nächsten Kapitel.

Praxis: Hinweise zum Zusammenklicken von Triggern

Die hier gezeigten Bilder stammen aus dem englischen Editor. Im deutschen Editor heißen die Befehle etwas anders, in der Regel sind sie jedoch fast wortwörtlich übersetzt, so dass es nicht all zu schwer sein sollte auch mit dem deutschen Editor dem Tutorial folgen zu können.

Am Anfang hat jeder das Problem, dass mand die Trigger, die sie auf den Bildern zu sehen sind nicht einfach abtippen kann, sondern sich die einzelnen Funktionen und ihre Bestandteile erst suchen muss. Der Editor bietet auch die Möglichkeit, so genanntes Custom Script zu verwenden, wo man Text einfach eingeben kann. Das ist aber nicht das selbe, wie wenn man den gleichen Text zusammen klickt, sondern vielmehr ein fortgeschrittenes Mittel um direkt die Scriptsprache zu benutzen, die dem GUI zugrunde liegt. Custom Scripts werden in diesem Tutorial nicht verwendet.

Wie findet man nun also eine gegebene Aktion? Im Allgemeinen gibt es hier zwei Wege:

  1. Man geht über die Kategorie, zu der eine Aktion gehört. Der Name einer Aktion steht immer am Anfang der Zeile. Zum Beispiel steht die Aktion "Unit - Kill (Triggering unit)" in der Kategorie "Unit".
  2. Man benutzt die Suchfunktion des Trigger-Editors und sucht nach Wörtern, die in der Zeile vorkommen. Zum Beispiel nach "Kill", wenn eine Einheit töten will.

Weitere Details, werden später erklärt. Solltet ihr trotzdem Probleme haben, so könnt ihr Fragen im IRC-Chat oder im Forum stellen. Wir werden diese Fragen dann auch wieder in das Tutorial einfließen lassen und es verbessern.

Praxis: Die ersten Trigger

Wir werden mit der ersten unserer vier Funktionen beginnen, da dies die grundlegenste Funktion ist und wir ohne diese auch nicht die anderen testen können.

Zur Erinnerung hier nochmal die Beschreibung der Funktion:

1. Einheiten-Erstellung Zu Beginn des Spiels soll ein Countdown-Timer starten, der darauf hinweist, wann die erste Gegnerwelle startet. Sobald der Timer abgelaufen ist, sollen an allen Creep-Startpunkten eine bestimmte Anzahl Einheiten eines bestimmten Typs erstellt werden und zum Ziel laufen. Gleichzeitig soll ein Countdown-Timer starten, der den Beginn der nächsten Runde anzeigt. Wenn dieser abgelaufen ist startet die zweite Gegner-Welle mit einem anderen Einheiten-Typ und eventuell auch einer anderen Anzahl von Gegnern (insgesamt sollte die Welle natürlich stärker sein als die davor). Unter dem Countdown-Timer soll immer angezeigt werden um welche Gegner es sich bei der nächsten Welle handelt.


In dieser Beschreibung steckt sehr viel drin, so dass es schwer ist einfach das ganze in Trigger umzuwandeln. Zum Glück gibt es aber Methoden, mit denen man systematisch an eine solche lange Beschreibung heran gehen kann. Eine Methode ist es, sich erst einmal zu überlegen, welche Daten wir für diese Funktion brauchen.

Variablen & Arrays

Die wichtigsten Daten sind bei einer TD wohl die Gegner. Wir brauchen eine Liste, in der für jede Welle der Gegnertyp und die Anzahl an Gegnern gespeichert ist. Dann müssen wir noch wissen, welchen Weg die Gegner laufen sollen. Das sind sozusagen die festen Daten, die von Anfang an fest stehen. Dann gibt es noch Daten, die sich im Laufe des Spiels ändern und sozusagen den Zustand des Spiels beschreiben. Bei uns ist das das momentane Level und die Anzahl der Leben, die die Spieler noch übrig haben.

Im Trigger-Editor benutzt man für solche Daten Variablen, denn diese können Daten speichern, wie wir aus dem Theorie-Teil wissen.

Beginnen wir mit den Daten für den Gegner-Typ. Also schnell den Trigger-Editor öffnen, falls er noch nicht offen ist. Unten links sollte dort der Auslöser "Melee Initialization" sein. Da wir keine Melee-Map erstellen, löschen wir diesen Auslöser zuerst einmal (aklicken und die Entfernen-Taste drücken).

tdtuttrigger02.jpg

Anschließend erstellen wir uns mit einem Klick auf tdtuttrigger03_neuerOrdner.jpg einen neuen Ordner und nennen ihn "Gegnerwellen". Man kann Elemente auch nachträglich umbenennen, indem man sie auswählt und dann die F2-Taste drückt.

Nun erstellen wir die Variable, in der die Gegnertypen gespeichert werden. Dazu den Ordner auswählen, in dem die Variable landen soll und auf tdtuttrigger04_neueVariable.jpg klicken. Als Namen wählen wir nun "Gegner Typ". Im rechten Teil des Fensters können wir weitere Einstellungen für die Variable treffen. Hier müssen wir zuerst den Typ ändern, da der standardmäßige Typ "Integer" nur ganze Zahlen speichern kann, wir aber Einheiten-Typen speichern wollen. Wir ändern den Typ der Variable also auf "Unit-Type". Da wir mehr als einen Einheiten-Typen haben wollen müssen wir noch das Häkchen bei Array setzen und daneben die Größe einstellen. 50 sollte für den Anfang auf jeden Fall ausreichen, wenn wir mehr brauchen können wir die Größe immer noch leicht erhöhen. Die Größe 50 bedeutet, dass wir in dieser Variable 50 Einheitentypen speichern können. Genau so eine Variable erstellen wir nun für die Anzahl der Gegner, wobei hier natürlich der Typ auf "Integer" bleibt, da die Anzahl der Gegner eine ganze Zahl ist. Die linke Seite des Auslöser-Editors sollte nun so aussehen:


tdtuttrigger05_Variablen.jpg


Nun müssen wir diese beiden Variablen natürlich noch mit Werten füllen. Dafür müssen wir einen Trigger erstellen, der bei Spielbeginn den Inhalt der Variablen festlegt.

Initialisierungstrigger

Einen Trigger erstellt man ähnlich wie Variablen: Man klickt auf tdtuttrigger06_neuerTrigger.jpg . Diesen Auslöser nennen wir nun "Gegner Initialisierung". Der leere Trigger sieht dann so aus:

Gegner Initialisierung

Events
Local Variables
Conditions
Actions

Unter Events stehen die Ereignisse, bei denen der Auslöser anspringen soll. Unter Local Variables stehen Variablen, die nur für einen Aufruf des Auslösers benötigt werden und danach wieder gelöscht werden können (diese werden wir später noch kennen lernen). Unter Conditions befinden sich Bedingungen, die erfüllt sein müssen damit die Aktionen (die unter Actions stehen ;) ausgeführt werden. Für unseren Trigger wollen wir als Event den Start der Karte haben, denn dort soll schon festgelegt werden, welche Gegnertypen es gibt. Als Aktion werden wir einfach den Inhalt unserer beiden Variablen setzen. Also zuerst einmal das Event. Dazu klicken wir auf das Symbol mit der Fahne tdtuttrigger07_neuesEvent.jpg . Es öffnet sich ein Fenster, in dem man aus jeder Menge von Events auswählen kann. "Map initialization" sollte schon standardmäßig ausgewählt sein und dies ist genau das Ereignis, das wir benötigen (Um andere Ereignisse zu finden kann man die Suchfunktion benutzen oder nach den Kategorien gehen, die links aufgelistet sind). Nun sollte unser Trigger so aussehen:

Gegner Initialisierung

Events
Game - Map initialization
Local Variables
Conditions
Actions

Jetzt brauchen wir noch die Aktionen, also das füllen der Variablen. Um eine neue Aktion zum Auslöser hinzuzufügen, klickt man auf das Symbol mit der Filmklappe tdtuttrigger08_neueAktion.jpg . Wie bei den Events auch, erscheint wieder ein Fenster, in dem man sich eine Aktion aussuchen kann. Wir benötigen die Aktion "Set Variable", die schon standardmäßig ausgewählt sein sollte, da sie wohl die am meisten benutzte Aktion ist (wenn man andere Aktionen sucht, kann man wieder die Suchfunktion benutzen oder nach den Kategorien auf der linken Seite gehen). Der Trigger-Editor sollte nun so aussehen:


tdtuttrigger09_setVariable.jpg


(1) ist der gesamte Trigger. (2) ist eine Detail-Ansicht der aktuell ausgewählten Aktion. (3) ist die aktuell ausgewählte Aktion. (4) ist eine Beschreibung der aktuell ausgewählten Aktion.

Aktionen haben normalerweise Parameter, für die man den Inhalt noch auswählen muss. Diese sind in (3) unterstrichen und in der Baum-Ansicht von (2) aufgelistet. In (3) kann man nun auf diese unterstrichenen Teile klicken und deren Inhalt festlegen.

Wir klicken also auf "Variable" und wählen dort unsere Variable "Gegner Typ" aus. Jetzt steht dort "Set Gegner Typ[0] = Value"

Die 0 in in eckigen Klammern ist die Nummerierung unserer Variable. Wir haben sie ja so eingestellt, dass sie 50 Werte speichern kann, also kann man an Stelle der 0 Werte zwischen 0 und 50 eintragen. Bei uns wird diese Nummer immer gleich der zugehörigen Gegner-Welle sein. Für die erste Gegner-Welle nehmen wir dort also die 1. Nun müssen wir noch den Wert rechts vom Gleichheitszeichen festlegen, also den Wert der in der Variable gespeichert werden soll. Wir wählen nun einfach mal den Zergling als ersten Gegner (lässt sich über die Suchfunktion schnell finden). Der ganze Trigger sollte nun so aussehen:

Gegner Initialisierung

Events
Game - Map initialization
Local Variables
Conditions
Actions
Variable - Set Gegner Typ[1] = Zergling

Nach dem gleichen Prinzip legen wir nun auch die Anzahl für die erste Welle fest. Und wiederholen das ganze für die zweite und dritte Welle:

Gegner Initialisierung

Events
Game - Map initialization
Local Variables
Conditions
Actions
Variable - Set Gegner Typ[1] = Zergling
Variable - Set Gegner Anzahl[1] = 10
Variable - Set Gegner Typ[2] = Hydralisk
Variable - Set Gegner Anzahl[2] = 5
Variable - Set Gegner Typ[3] = Drone
Variable - Set Gegner Anzahl[3] = 50

In der ersten Welle kommen also 10 Zerglinge, danach 5 Hydralisken und dann 50 Dronen. Diese Werte kann man natürlich beliebig anpassen.

Timer & Aktionen

Nachdem wir nun festgelegt haben, welche Einheiten spawnen sollen wollen wir uns um den Auslöser kümmern, der die Einheiten erstellt. Zur Erinnerung: Wir wollten zuerst einen Timer starten und wenn dieser abläuft die Gegner erstellen.

Erstellen wir also zuerst einmal den Timer. Dafür brauchen wir eine neue Variable vom Typ "Timer", die wir "Gegner Timer" nennen. Nun brauchen wir noch einen neuen Trigger, der diesen Timer startet. Dieser Trigger besteht nur aus einem Ereignis und einer Aktion. Da der Trigger zu Spielbeginn starten soll, wählen wir als Ereignis "Timer - Elapsed time is 0.0 Game Time seconds". Mit der Aktion starten wir dann den Timer. Der Trigger sieht dann so aus:

Timer starten

Events
Timer - Elapsed time is 0.0 Game Time seconds
Local Variables
Conditions
Actions
Timer - Start Gegner Timer as a One Shot timer that will expire in 20.0 Game Time seconds

Das Ereignis und die Aktion sollten mit der eingebauten Such-Funktion leicht zu finden sein. Findet man etwas mit der Suchfunktion nicht, so kann man sich auch nach der Kategorie richten - das erste Wort einer Zeile gibt immer an, in welcher Kategorie man eine Aktion finden kann.

Bei den einzelnen Parametern einer Aktion muss man oft zuerst die Entscheidung treffen, ob man hier eine Funktion, ein Preset, einen Parameter, eine Variable oder einen von Hand eingegeben Wert benutzen will (Custom Script ist noch eine weitere Option für fotgeschrittene).


tdtuttrigger17_parameter.jpg

Außerdem muss man sich klar machen, welcher Typ der Parameter hat, in folgendem Beispiel ist es eine ganze Zahl (Integer):


tdtuttrigger18_parameter.jpg

Also wann wählt man welche Option?

"Value" wählt man, wenn man einen festen Wert direkt per Hand als Parameter eintragen will. "Variable" wählt man, wenn man eine Variable einsetzen will. Hier muss man darauf achten, dass die Variable den Richtigen Typ hat. Oft ist es nötig erst eine Conversion-Funktion aufzurufen bevor man die gewünschte Variable benutzen kann. Will man zum Beispiel einen Integer in einem Text ausgeben, so muss man den Integer erst mit einer solchen Funktion in einen Text umwandeln und kann nicht direkt die Integer-Variable auswählen. "Parameter" kann man genau wie Variable benutzen, das sind die Parameter von eigenen Aktionen und Funktionen. "Preset" sind voreingestellte Werte - will man den Spieler-Status prüfen, so kann man hier zum Beispiel aus den vorgegebenen Werten "unused", "playing" und "Left the game" wählen - Presets sind also nur bei manchen Datentypen interessant. "Function" wählt man wie der Name schon sagt, wenn man eine Funktion benutzen will, also wenn man mehr machen will als die bisherigen Möglichkeiten von Values und Variablen bieten.

Punkte und 2D-Arrays

Als nächstes wollen wir uns um die Erstellung der Einheiten beschäftigen. Dazu müssen wir nun erst einmal festlegen, welche Wege die Einheiten laufen sollen. Das folgende Bild zeigt die Laufwege für einen Startpunkt und eine Richtung:


tdtuttrigger_map1.jpg

Wir müssen nun im Terrain-Editor (im Layer Points) an jeder Ecke einen Punkt erstellen. Man könnte hier auch Ecken weg lassen, aber dann würden Lufteinheiten einfach außerhalb der Wege fliegen und Einheiten würden an Ecken immer innen laufen. Wenn dies gewollt ist, kann man das jedoch machen und sich so Zeit sparen.

Wenn man alle Ecken markiert bekommt man recht viele Punkte, so dass es sinnvoll ist die Punkte nach einem Koordinatensystem zu benennen, wie das folgende Bild zeigt:


tdtuttrigger_map2.jpg


Wir werden nun alle Wege bis zu den gelb markierten Stellen in Arrays speichern. An der gelben Stelle sollen sich die Einheiten aufspalten, was wir seperat behandeln werden.


tdtuttrigger_map3.jpg


Zum Speichern der Wege benutzen wir ein Array von Array von Punkten, also ein 2D-Array. Hierzu erstellt man einfach ganz normal ein Array, trägt als Typ Point ein und benutzt nun die ersten beiden Felder für Größe. Im obersten Feld tragen wir als Größe 8 ein, im Feld darunter 10. Das reicht für unser Beispiel auf jeden Fall aus.

Die Wegpunktinitialisierung für alle 8 möglichen Wege sieht dann so aus:

Wegpunkt Initialisierung

Events
Game - Map initialization
Local Variables
weg = 0 <Integer>
Conditions
Actions
------- 1. Weg (von oben links nach rechts)
Variable - Set weg = 0
Variable - Set Wegpunkte[weg][0] = Start OL
Variable - Set Wegpunkte[weg][1] = wegpunkt 3,1
Variable - Set Wegpunkte[weg][2] = wegpunkt 3,2
Variable - Set Wegpunkte[weg][3] = wegpunkt 4,2
Variable - Set Wegpunkte[weg][4] = wegpunkt 4,3
------- 2. Weg (von oben links nach unten)
Variable - Set weg = 1
Variable - Set Wegpunkte[weg][0] = Start OL
Variable - Set Wegpunkte[weg][1] = wegpunkt 1,3
Variable - Set Wegpunkte[weg][2] = wegpunkt 2,3
Variable - Set Wegpunkte[weg][3] = wegpunkt 2,4
Variable - Set Wegpunkte[weg][4] = wegpunkt 3,4
------- 3. Weg (von oben rechts nach links)
Variable - Set weg = 2
Variable - Set Wegpunkte[weg][0] = Start OR
Variable - Set Wegpunkte[weg][1] = wegpunkt 5,1
Variable - Set Wegpunkte[weg][2] = wegpunkt 5,2
Variable - Set Wegpunkte[weg][3] = wegpunkt 4,2
Variable - Set Wegpunkte[weg][4] = wegpunkt 4,3
------- 4. Weg (von oben rechts nach unten)
Variable - Set weg = 3
Variable - Set Wegpunkte[weg][0] = Start OR
Variable - Set Wegpunkte[weg][1] = wegpunkt 7,3
Variable - Set Wegpunkte[weg][2] = wegpunkt 6,3
Variable - Set Wegpunkte[weg][3] = wegpunkt 6,4
Variable - Set Wegpunkte[weg][4] = wegpunkt 5,4
------- 5. Weg (von unten rechts nach oben
Variable - Set weg = 4
Variable - Set Wegpunkte[weg][0] = Start UR
Variable - Set Wegpunkte[weg][1] = wegpunkt 7,5
Variable - Set Wegpunkte[weg][2] = wegpunkt 6,5
Variable - Set Wegpunkte[weg][3] = wegpunkt 6,4
Variable - Set Wegpunkte[weg][4] = wegpunkt 5,4
------- 6. Weg (von unten rechts nach links)
Variable - Set weg = 5
Variable - Set Wegpunkte[weg][0] = Start UR
Variable - Set Wegpunkte[weg][1] = wegpunkt 5,7
Variable - Set Wegpunkte[weg][2] = wegpunkt 5,6
Variable - Set Wegpunkte[weg][3] = wegpunkt 4,6
Variable - Set Wegpunkte[weg][4] = wegpunkt 4,5
------- 7. Weg (von unten links nach rechts)
Variable - Set weg = 6
Variable - Set Wegpunkte[weg][0] = START UL
Variable - Set Wegpunkte[weg][1] = wegpunkt 3,7
Variable - Set Wegpunkte[weg][2] = wegpunkt 3,6
Variable - Set Wegpunkte[weg][3] = wegpunkt 4,6
Variable - Set Wegpunkte[weg][4] = wegpunkt 4,5
------- 8. Weg (von oben rechts nach oben)
Variable - Set weg = 7
Variable - Set Wegpunkte[weg][0] = START UL
Variable - Set Wegpunkte[weg][1] = wegpunkt 1,5
Variable - Set Wegpunkte[weg][2] = wegpunkt 2,5
Variable - Set Wegpunkte[weg][3] = wegpunkt 2,4
Variable - Set Wegpunkte[weg][4] = wegpunkt 3,4

Wie man sieht haben die Arrays nun 2 Indizes. Den ersten Index nehmen wir für die Nummer des Weges, der zweite beschreibt welcher Wegpunkt es ist. Die (lokale) Hilfs-Variable "weg" benutze ich, damit ich nach dem kopieren nicht in jeder Zeile einzeln den Index für den Weg eintragen muss.

Nun, da wir die Daten haben, beginnen wir mit dem Trigger, der die Einheiten erstellt. Um den eigentlichen Trigger kurz und übersichtlicher zu halten lagern wir das Erstellen der Einheiten erst einmal in eine eigene Aktion aus.

Eigene Aktionen

Eine eigene Aktion erstellt man mit dem Filmklappe-Button tdtuttrigger12_neueAktionDefinition.jpg . Diese Aktion nennen wir "Gegner erstellen". Für Aktionen kann man Parameter festlegen, also Werte von denen die Aktion abhängig ist. Bei uns ist dies der Einheitentyp und der Weg, den die erstellte Einheit gehen soll. Parameter werden über den Button mit dem Lambda und dem Gleichheitszeichen tdtuttrigger13_neuerParameter.jpg erstellt. Die Funktion sieht dann mit diesen zwei Parametern so aus:

Gegner erstellen

Options: Action
Return Type: (None)
Parameters
Einheitentyp = No Game Link <Game Link - Unit>
weg = 0 <Integer>
Grammar Text: Gegner erstellen(Einheitentyp, weg)
Hint Text: (None)
Custom Script Code
Local Variables
Actions

In der ersten Aktion erstellen wir nun den Gegner für Spieler 10:

       Unit - Create 1 Einheitentyp for player 10 at Wegpunkte[weg][0] facing Ziel (No Options)

Anschließend geben wir dieser Einheit Befehle, die Wegpunkte des Weges abzulaufen, also die Punkte 1 bis 5. Dafür bietet sich eine Schleife an, da wir hier fünf mal die gleiche Aktion haben. Für eine For-Schleife erstellt man sich einfach ein lokale Variable (hier "i"), setzt sie in die For-Schleife ein und im Spiel zählt die For-Schleife diese Variable dann einfach vom Startwert (hier 1) zum Endwert (hier 5), wobei sie für jeden Schritt die Aktionen in der Schleife einmal ausführt. In der Schleife hängen wir dann einfach einen Move-Befehl an die aktuellen Befehle der Einheit "(After Existing Orders)". Ohne diese Option würde die Einheit nur den letzten Befehl ausführen, mit dieser Option ist es so, als ob man im Spiel die shift-Taste gedrückt hält wärend man die Befehle gibt. Anschließend kann man noch den "Grammar Text" anpassen, damit es schöner aussieht, wenn man die Aktion benutzt, dies ist aber optional, also ändert nichts an der Funktionsweise der Auslöser. Allerdings sehen die folgenden Trigger etwas anders aus, wenn man dies nicht tut. Im Grammar Text befindet sich unten eine Auswahlbox, mit der man die Parameter in den Text einfügen kann. Diese tauchen dort dann Unterstrichen auf:

tdtuttrigger_GrammarText.jpg

Die ganze Aktionsdefinition sieht dann so aus:

Gegner erstellen

Options: Action
Return Type: (None)
Parameters
Einheitentyp = No Game Link <Game Link - Unit>
weg = 0 <Integer>
Grammar Text: Erstelle einen Gegner vom Typ Einheitentyp auf dem Weg Nummer weg
Hint Text: (None)
Custom Script Code
Local Variables
i = 0 <Integer>
Actions
Unit - Create 1 Einheitentyp for player 10 at Wegpunkte[weg][0] facing Ziel (No Options)
General - For each integer i from 1 to 4 with increment 1, do (Actions)
Actions
Unit - Order (Last created unit) to ( Move targeting Wegpunkte[weg][i]) (After Existing Orders)

Die letzte Aktion nochmal in der Detailansicht, da der Move-Befehl sonst nicht so leicht zu finden ist (wie man unten sieht muss man erst "Order Targeting Point" auswählen):

Issue Order

Unit: Last Created Unit
Order: Order Targeting Point
Ability Command: Move
Target Point: Wegpunkte
Index 1: weg
Index 2: i
Queue: After Existing Orders

Nachdem wir diese Aktion fertig erstellt haben können wir mit dem Trigger zum Einheitenerstellen beginnen. Hier erhöhen wir nun einfach die Zählvariable für die aktuelle Gegnerwelle um eins, erstellen dann für jeden Weg die Gegner (falls der zugehörige Spieler auch im Spiel ist, dafür ist der If-Block) und starten anschließend den Timer für die nächste Runde. Insgesamt sieht dies dann so aus (ein paar Tipps zum zusammen klicken des Triggers folgen später):

nächste Welle

Events
Timer - Gegner Timer expires
Local Variables
i = 0 <Integer>
Conditions
Actions
Variable - Set Gegner Welle = (Gegner Welle + 1)
------- Gegner erstellen:
General - Repeat (Actions) Gegner Anzahl[Gegner Welle] times
Actions
General - For each integer i from 0 to 7 with increment 1, do (Actions)
Actions
------- Wenn Spieler spielt -> erstelle Gegner auf seinem Weg
General - If (Conditions) then do (Actions) else do (Actions)
If
(Status of player (i + 1)) == Playing
Then
Erstelle einen Gegner vom Typ Gegner Typ[Gegner Welle] auf dem Weg Nummer i
Else
General - Wait 0.5 Game Time seconds
------- nächste Welle starten
Trigger - Run Timer starten (Check Conditions, Don't Wait until it finishes)


Hier haben wir nun zwei Schleifen ineinander verschachtelt. Die äußere Repeat-Schleife sorgt dafür, dass das Erstellen der Gegner so oft passiert, wie wir im Array "Gegner Anzahl" für die aktuelle Welle festgelegt haben. Die innere For-Schleife geht alle 8 Wege durch und erstellt an jedem Weg eine Einheit, vorher wird aber natürlich geprüft, ob auf diesem Weg überhaupt ein Spieler spielt. Der Wait-Befehl in der äußeren Schleife sorgt dann dafür, dass nicht alle Einheiten auf einmal erstellt werden, sondern immer eine halbe Sekunde Zeit zwischen ihnen liegt. Das verhindert Lags und hässliche Klumpenbildung von Gegnern ;)

Erfahrungsgemäß haben die meisten Menschen Probleme, wenn sie das erste mal mit verschachtelten Schleifen zu tun haben. Hier kann es dem Verständnis helfen, wenn man das ganze einmal auf dem Papier durchspielt und sich Zeile für Zeile vorarbeitet.

Beim Zusammenbauen dieses Triggers benötigen wir zum ersten mal Rechenoperationen (Addition). Diese findet man unter Arithmetic, wie die Detailansicht der ersten Aktion auch zeigt:

Set Variable

Variable: Gegner Welle
Value: Arithmetic (Integer)
Value 1: Gegner Welle
Operator: +
Value 2: 1

Bedingungen & Zufall

Mit diesen Triggern laufen unsere Gegner allerding erst zu den auf der Karte gelb markierten Stellen. An dieser Stelle sollen sich die Einheiten aufspalten, und zufällig in eine der zwei möglichen Richtungen laufen. Dies regeln wir durch einen vier weitere Trigger, hier der Trigger für oben:

aufspalten oben

Events
Unit - Any Unit Enters within 4.0 of wegpunkt 4,3
Local Variables
Conditions
(Owner of (Triggering unit)) == 10
Actions
General - If (Conditions) then do (Actions) else do (Actions)
If
(Random integer between 0 and 1) == 1
Then
Unit - Order (Triggering unit) to ( Move targeting wegpunkt 3,3) (After Existing Orders)
Else
Unit - Order (Triggering unit) to ( Move targeting wegpunkt 5,3) (After Existing Orders)
Unit - Order (Triggering unit) to ( Move targeting Ziel) (After Existing Orders)


Was machen wir hier? Das Ereignis sagt, dass der Trigger auslösen soll, wenn eine Einheit den Bereich vier Meter um den Wegpunkt 3,4 betritt. Hat man ein solches Ereignis, das von einer Einheit ausgelöst wird, so kann man die Funktion "Triggering unit" verwenden, welche sich dann auf diese Einheit bezieht. Mit der Bedingung des Auslösers sorgen wir dafür, dass er nur bei Gegnern anspringt und nicht nachher im Spiel unseren eigenen Einheiten Befehle gibt.

Welchen Befehl wir der Einheit nun geben hängt nun vom Zufall ab. Wir machen also eine Fallunterscheidung (If-then-else) und machen die Entscheidung von der Random-Funktion abhängig, die eine zufällige Zahl als Ergebnis liefert. Ist die Zahl 1 so läuft die Einheit nach links, ansonsten (also wenn die Zahl 0 ist) läuft die Einheit nach rechts. Nach der Fallunterscheidung kommt dann wieder eine Aktion die unabhängig vom Zufall ist und damit außerhalb des If-Then-Else Blocks liegt: Die Einheit soll zum Ziel laufen. Nach dem gleichen Prinzip erstellen wir noch drei Trigger für die anderen Richtungen.

Dialoge & Timer

Jetzt brauchen wir noch Trigger, die die Leben anzeigen und herunter zählen, wenn eine Einheit ins Ziel kommt. Für die Anzeige der Leben erstellen wir uns einen Dialog, wofür wir folgende Variablen brauchen:

       leben Dialog = No Dialog <Dialog>
       leben Label = No Dialog Item <Dialog Item>

Die Leben selbst werden in einer Integer Variable "Leben" gespeichert.

   leben = 10 <Integer>

Den Dialog erstellt man dann einfach am Anfang des Spiels mit folgendem Trigger:

Leben anzeigen

Events
Timer - Elapsed time is 5.0 Game Time seconds
Local Variables
Conditions
Actions
Dialog - Create a Modal dialog of size (250, 70) at (20, 120) relative to Top Right of screen
Variable - Set leben Dialog = (Last created dialog)
Dialog - Create a Label for Dialog (Last created dialog) with the dimensions (150, 50) anchored to Top Left with an offset of (50, 20) with the text ("Leben: " + (Text(Leben))) color set to White text writeout set to false with a writeout duration of 2.0
Variable - Set leben Label = (Last created dialog item)
Dialog - Show (Last created dialog) for (All players)

In der dritten Zeile bauen wir uns einen Text aus zwei Bestandteilen zusammen. Dies funktioniert über die Funktion "Text: Combine Text", wie man in der folgenden Detail-Ansicht sieht:

Create Dialog Item (Label)

Dialog: Last Created Dialog
Width: 150
Height: 50
Anchor: Top Left
Offset X: 50
Offset Y: 20
Text: Combine Text
Text 1: "Leben: "
Text 2: Convert Integer To Text
Value: leben
Color: White
Text Writeout: false
Text Writeout Duration: 2.0

Dort sieht man ebenfalls, dass die Leben erst in einen Text umgewandelt werden muss, da die zwei unterschiedlichen Datentypen Text und Integer sonst nicht kompatibel sind.

Wenn eine Einheit ins Ziel kommt, reagieren wir darauf mit folgendem Trigger:

Gegner kommt ins Ziel

Events
Unit - Any Unit Enters within 2.0 of Ziel
Local Variables
player = 0 <Integer>
Conditions
(Owner of (Triggering unit)) == 10
Actions
Variable - Set Leben = (Leben - 1)
Unit - Kill (Triggering unit)
Dialog - Set leben Label text to ("Leben: " + (Text(Leben))) for (All players)
General - If (Conditions) then do (Actions) else do (Actions)
If
Leben <= 0
Then
Player Group - For each player player in (All players) do (Actions)
Actions
Game - End game in Defeat for player player (Show dialogs, Show score screen)
Else

Die erste Zeile des Triggers verwendet eine Rechenoperation. Diese befinden sich unter Arithmetic, wie die Detailansicht der Aktion zeigt:

Set Variable

Variable: leben
Value: Arithmetic (Integer)
Value 1: leben
Operator: -
Value 2: 1

Was passiert nun im gesamten Trigger? Die Leben werden eins runter gezählt, das Textfeld, welches die Leben anzeigt, aktualisiert und die Einheit, die das Ziel betritt wird getötet. Außerdem wird überprüft, ob überhaupt noch Leben übrig sind, oder ob das Spiel nicht schon verloren ist. Wenn keine Leben mehr übrig sind, wird das Spiel für alle Spieler beendet.

Spielergruppen

Verlieren kann man nun schon, man sollte allerdings auch gewinnen können. Dazu erstellen wir uns einen Trigger, der auslöst, wenn ein Gegner stirbt und dann prüft ob dies bereits das letzte Level und der letzte Gegner war.

Sieg

Events
Unit - Any Unit dies
Local Variables
player = 0 <Integer>
Conditions
Actions
General - If (Conditions) then do (Actions) else do (Actions)
If
Gegner Welle >= 3
(Player 10 Supplies Used) == 0
Then
UI - Display "Sie haben das Spiel gewonnen!" for (All players) to Objective area
General - Wait 30.0 Game Time seconds
Player Group - For each player player in (All players) do (Actions)
Actions
Game - End game in Victory for player player (Show dialogs, Show score screen)
Else

Die erste Bedingung muss natürlich immer so angepasst werden, dass es sich dabei um die höchste Welle handelt, bis jetzt hatten wir ja nur 3 Gegner festgelegt.

Startpositionen und Spielereigenschaften

Nun kommen wir so langsam zum Ende - oder doch eher zum Anfang? Der fehlt nämlich noch. Wir müssen noch die Startpositionen und Starteinheiten für die Spieler erstellen. Startpositionen erstellt man im Terrain-Editor über den Punkte-Layer. Dort findet man folgenden Button über den man die Positionen setzen kann: tdtuttrigger16_startlocation.jpg


tdtuttrigger15_startlocation.jpg

Nun muss man noch unter Map->Player Properties die Startpositionen setzen und festlegen, welche Spieler von Benutzern gesteuert werden:


tdtuttrigger14_playerProperties.jpg

Nun können wir diese Startposition auch ausnutzen um im Start-Trigger einen Worker für jeden Spieler zu erstellen, der spielt:

Start

Events
Game - Map initialization
Local Variables
player = 0 <Integer>
players = (Empty player group) <Player Group>
Conditions
Actions
Visibility - Disable Fog Of War visibility
Visibility - Disable Black Mask visibility
General - For each integer player from 1 to 8 with increment 1, do (Actions)
Actions
General - If (Conditions) then do (Actions) else do (Actions)
If
(Status of player player) == Playing
Then
Unit - Create 1 Worker for player player at (Start location of player player) using default facing (No Options)
Player Group - Add player player to players
Player - Modify player player Minerals: Set To 1000
Else
Player - Make all players in players treat each other as Ally With Shared Vision

In diesem Trigger wird nun ebenfalls festgelegt, dass alle Spieler miteinander verbündet sein sollen. Dazu werden innerhalb der Schleife erst alle Spieler in die Gruppe "players" gepackt und dann mit dem letzten Befehl verbündet.

Texte & Dialoge

Im Prinzip sind wir nun mit den Triggern fertig, um den Spielern das Leben ein bisschen einfacher zu gestalten wollen wir aber noch Informationen über den nächsten Gegner und einen kleinen Timer anzeigen. Dazu erweitern wir den Dialog, in dem momentan nur die Leben angezeigt werden und fügen dort noch ein weiteres Label hinzu. Der gesamte Trigger sieht dann so aus:

Leben anzeigen

Events
Timer - Elapsed time is 5.0 Game Time seconds
Local Variables
Conditions
Actions
Dialog - Create a Modal dialog of size (350, 170) at (20, 40) relative to Top Right of screen
Variable - Set leben Dialog = (Last created dialog)
Dialog - Create a label for dialog (Last created dialog) with the dimensions (250, 100) anchored to Top Left with an offset of (50, 65) with the text "nächster Gegner:" color set to White text writeout set to false with a writeout duration of 2.0
Variable - Set next Enemy Label = (Last created dialog item)
Dialog - Create a label for dialog (Last created dialog) with the dimensions (250, 50) anchored to Top Left with an offset of (50, 35) with the text ("Leben: " + (Text(Leben))) color set to White text writeout set to true with a writeout duration of 5.0
Variable - Set leben Label = (Last created dialog item)
Dialog - Show (Last created dialog) for (All players)

Für das neue Label wurde wie man sieht auch eine neue Variable eingeführt. Das neue Label aktualisieren wir nun jede Sekunde mit folgendem Trigger:

Dialog aktualisieren

Events
Timer - Every 1.0 seconds of Game Time
Local Variables
text = No Text <Text>
Conditions
Actions
General - If (Conditions) then do (Actions) else do (Actions)
If
Gegner Welle < 3
Then
Variable - Set text = "nächste Welle: $$"
Variable - Set text = (text + (Text(Gegner Anzahl[(Gegner Welle + 1)])))
Variable - Set text = (text + "x ")
Variable - Set text = (text + (Name of Gegner Typ[(Gegner Welle + 1)]))
Variable - Set text = (text + "$$")
Variable - Set text = (text + (Format Duration((Integer((Remaining time of Gegner Timer))))))
Else
Variable - Set text = "letzte Welle "
Dialog - Set next Enemy Label text to text for (All players)

An Stelle von $$ solltet ihr einfach einen Zeilenumbruch machen, dieser wird aber leider in der Trigger-Ansicht nicht mehr angeziegt.

Hier verwenden wir die Hilfsvariable "text" um den langen Text in mehreren Schritten mit Combine Text zusammen bauen zu können. So bleibt das ganze übersichtlicher.

Das war es für den Trigger-Teil dieses Tutorials, bei Fragen hierzu findet ihr Hilfe im Trigger-Forum.

Schlusswort

Wir haben nun eine einfache Turm-Verteidigung erstellt und ihr solltet nun in der Lage sein, grundlegende Dinge mit dem Daten- und dem Triggereditor erstellen zu können.

Einen Download der Map, die bei diesem Tutorial entstanden ist, werden wir in Kürze bereit stellen.

Autoren: Mo93 , Peq