Es geht weiter!

Nach fast einem Jahr Pause geht es nun weiter mit dem Projekt OctoAwesome! Das NoobDevTv-Team versucht wieder regelmäßig Donnerstags um 19 Uhr einen OctoAwesome-Stream auf den Streaming-Kanäle von NoobDevTv: Twitch, Youtube und Mixer. zu veranstalten! Die neu produzierten Folgen der nun dritten Staffel werden ab jetzt auf deren Youtube-Kanal veröffentlicht.

Extensions: Unterschied zwischen den Versionen

Aus OctoAwesome Wiki
Wechseln zu: Navigation, Suche
K (Überarbeiten-Hinweis)
K (Bilddarstellung gefixt)
 
(7 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 1: Zeile 1:
 
{{Überarbeiten}}[[Kategorie:Überarbeiten]]
 
{{Überarbeiten}}[[Kategorie:Überarbeiten]]
  
In diesem Artikel geht es um das Entwickeln von Erweiterungen für das Projekt OctoAwesome.
+
'''Dieser Artikel beschreibt den neuen Lademechanismus aus dem Branch feature/entities'''
  
Zur Zeit lassen sich (im master-Branch)
+
In diesem Artikel geht es um das Entwickeln von eigenen Erweiterungen für das Projekt OctoAwesome, nicht um das Verwalten dieser.
  
* Blocktypen
+
==Erweiterungen erstellen==
 +
Erweiterungen müssen in allen Fällen eine eigene .dll Dateien sein, die entweder direkt im Programmverzeichnis oder im Unterverzeichnis <code>Plugins</code> liegen müssen. Zur Entwicklung verwendet man am besten [[VisualStudio]] oder [[MonoDevelop]]. Der Namespace- und Assemblyname sollte im Format <code>OctoAwesome.*</code> oder <code>OctoAwesome.Plugin.*</code> sein. In einer einzelnen Erweiterung können mehrere erweiternde Typen definiert sein.
 +
 
 +
Eine Erweiterung ist eine Klasse, die von <code>IExtension</code> abgeleitet ist. Alle solchen Klassen werden beim Programmstart geladen, wenn der Nutzer sie aktiviert hat. Die Erweiterungsklasse enthält Informationen zur Erweiterung und Code für den Anwendungstart. Darüber können mit dem übergebenen <code>IExtensionLoader</code> einzelne Typen für das Spiel registriert werden:
 +
 
 +
* Definitions (= Blocktypen, Items und Baumtypen)
 
* Map Populators
 
* Map Populators
* Baumtypen (in Verbindung mit der Basiserweiterung)
+
* Map Generatoren (noch keine Auswahl möglich)
<!--* Map Generatoren-->
+
* Entitytypen
 +
* Extender für Entitäten und die Simulation
 +
 
 +
Für alle Erweiterungen wird ein Verweis auf <code>OctoAwesome.dll</code> benötigt.
 +
 
 +
; Beispielimplementierung:
 +
: [https://github.com/OctoAwesome/octoawesome/blob/feature/entities/OctoAwesome/OctoAwesome.Basics/Extension.cs Extension.cs auf GitHub]
 +
 
 +
''Die Dokumentation zu den einzelnen Typen wird zur Zeit überarbeitet und wird in Kürze wieder online sein.''
  
durch eigene Erweiterungen ausbauen. Weitere Typen (z.B. Items, Resources, NPCs) sind für die Zukunft geplant.
+
===Definitonstypen===
  
Erweiterungen müssen in allen Fällen eine eigene .dll Dateien sein, die entweder direkt im Programmverzeichnis oder im Unterverzeichnis <code>Plugins</code> liegen müssen. Zur Entwicklung verwendet man am besten [[VisualStudio]] oder [[MonoDevelop]]. Der Namespace- und Assemblyname sollte im Format <code>OctoAwesome.*</code> oder <code>OctoAwesome.Plugin.*</code> sein. In einer einzelnen Datei können mehrere erweiternde Typen definiert sein.
+
; Beispielimplementierungen:
 +
: [https://github.com/OctoAwesome/octoawesome/blob/feature/entities/OctoAwesome/OctoAwesome.Basics/Definitions/Blocks/GrassBlockDefinition.cs Blocktyp (GrassBlockDefintion.cs) auf GitHub]
 +
: [https://github.com/OctoAwesome/octoawesome/blob/feature/entities/OctoAwesome/OctoAwesome.Basics/Definitions/Items/WauziEggDefinition.cs Item (WauziEggDefinition.cs) auf GitHub]
 +
: [https://github.com/OctoAwesome/octoawesome/blob/feature/entities/OctoAwesome/OctoAwesome.Basics/Definitions/Trees/CactusTreeDefinition.cs Baumtyp (CactusTreeDefintion.cs) auf GitHub]
  
==Blocktypen==
+
Mit einer Defintion wird dem Spiel ein neues Spielelement definiert. Dabei gibt es bisher drei mögliche Definitionstypen.
  
;Benötigte Verweise:
+
====Blocktypen====
: OctoAwesome.dll
+
Blocktypen implementieren entweder die Basisschnittstelle <code>[http://doc.octoawesome.net/api/develop/OctoAwesome.IBlockDefinition.html IBlockDefinition]</code> oder erben von der Basisklasse <code>[http://doc.octoawesome.net/api/develop/OctoAwesome.BlockDefinition.html BlockDefinition]</code>. Der Vorteil der Basisklasse ist, dass sie bereits viel Standardcode enthält, der nicht in jeden Blocktyp kopiert werden muss.
;Beispielimplementierung(en):
 
: [https://github.com/OctoAwesome/octoawesome/blob/master/OctoAwesome/OctoAwesome.Basics/Definitions/Blocks/SandBlockDefinition.cs SandBlockDefinition.cs auf GitHub]: Einfacher Blocktyp
 
: [https://github.com/OctoAwesome/octoawesome/blob/master/OctoAwesome/OctoAwesome.Basics/Definitions/Blocks/GrassBlockDefinition.cs GrassBlockDefinition.cs auf GitHub]: Komplexerer Blocktyp
 
  
Blocktypen erben implementieren die Basisschnittstelle <code>[http://doc.octoawesome.net/master/html/T_OctoAwesome_IBlockDefinition.htm IBlockDefinition]</code> oder erben von der Basisklasse <code>[http://doc.octoawesome.net/master/html/T_OctoAwesome_BlockDefinition.htm BlockDefinition]</code>. Der Vorteil der Basisklasse ist, dass sie bereits viel Standardcode enthält, der nicht in jeden Blocktyp kopiert werden muss.
+
Die Texturen des Blocks werden als Array von ''Asset-Referenzen'' (ohne Dateiendung) dem Spiel übergeben. Diese müssen als Bilddatei mit dem gleichen Namen (aber mit Dateiendung) als Eingebettete Ressource im Ordner Assets des jeweiligen Assemblies liegen. Als Unterordner müssen die Namespacenamensteile (jeder Punkt trennt ein Verzeichnis) ohne den Assemblynamen am Anfang verwendet werden. Hat z.B. ein <code>XYZBlock</code> den Namespacenamen <code>OctoAwesome.XYZ.Blocks</code> aus dem Assembly <code>OctoAwesome.XYZ</code> und verwendet die Textur <code>xyz</code>, so muss die Texturdatei den Pfad <code>${PROJEKTVERZEISCHNIS}/Assets/Blocks/xyz.png</code> haben. Alternativ können auch jpg oder bmp Dateien verwendet werden.
  
Die Texturen des Blocks werden als Array von <code>Bitmap</code>s dem Spiel übergeben. Diese können entweder im Dateisystem liegen (besipielsweise im png-Format, wie bei der Basiserweiterung) oder als Resourcen in der dll-Datei des Plugins. Zum Laden aus dem Dateisystem sollte die [[Verzeichnisstruktur]] eingehalten werden. Insbesondere sollte im Assets-Verzeichnis auf die Verwendung des Assemblynamens (ohne Dateiendung) als Unterordner geachtet wird. Unterhalb dieses Ordners dürfen beliebige Ordner verwendet werden.
+
Die Methoden <code>GetProperties()</code> und <code>Hit()</code> müssen zwar implementiert werden, werden aber nicht vom Spiel verwendet. Das <code>Icon</code> und der <code>Name</code> werden im Spiel angezeigt, aber nicht zur internen Identifikation eingesetzt, können also lokalisiert werden.
  
Die Methoden <code>GetPhysicalProperties()</code> und <code>Hit()</code> müssen zwar implementiert werden, werden aber nicht vom Spiel verwendet. Das <code>Icon</code> und der <code>Name</code> werden im Spiel angezeigt, aber nicht zur internen Identifikation eingesetzt, können also lokalisiert werden.
+
====Baumtypen====
 +
Als weiterer Verweis muss ein Verweis auf <code>OctoAwesome.Basics.dll</code> hinzugefügt werden.
  
==Map Populators==
+
Baumtypen implementieren entweder die Basisschnittstelle <code>[http://doc.octoawesome.net/api/develop/OctoAwesome.Basics.ITreeDefinition.html ITreeDefinition]</code> oder erben von der Basisklasse <code>[http://doc.octoawesome.net/api/develop/OctoAwesome.Basics.TreeDefinition.html TreeDefinition]</code>.
  
;Benötigte Verweise:
+
Über <code>MinTemperature</code>, <code>MaxTemperature</code> und <code>GetDensity()</code> werden die Minimal-/Maximaltemperaturen für diesen Baum und die Häufigkeit des Auftretens ermittelt. In der Methode <code>Init()</code> können die benötigten Blocktypen herausgesucht werden und dann schließlich in der Methode <code>PlantTree()</code> zum "Pflanzen" eines Baumes an der angegebenen Position verwendet werden.
: OctoAwesome.dll
+
<!--
;Beispielimplementierung(en):
+
====Items====
: [https://github.com/OctoAwesome/octoawesome/blob/master/OctoAwesome/OctoAwesome.Basics/TreePopulator.cs TreePopulator.cs auf GitHub]
+
ItemDefintions erben implementieren die Basisschnittstelle <code>[http://doc.octoawesome.net/api/develop/OctoAwesome.IItemDefinition.html IItemDefinition]</code>. ERGÄNZEN!
 +
-->
 +
===Map Populators===
  
Blocktypen implementieren entweder die Basisschnittstelle <code>[http://doc.octoawesome.net/master/html/T_OctoAwesome_IMapPopulator.htm IMapPopulator]</code> oder erben von der Basisklasse <code>[http://doc.octoawesome.net/master/html/T_OctoAwesome_MapPopulator.htm MapPopulator]</code>.
+
;Beispielimplementierung:
 +
: [https://github.com/OctoAwesome/octoawesome/blob/feature/entities/OctoAwesome/OctoAwesome.Basics/TreePopulator.cs TreePopulator.cs auf GitHub]
  
<code>Order</code> definiert die Reihenfolge, in der die Populatoren auf die Welt angewendet wird. In der Methode <code>Populate()</code> wird ein Chunk mit Dingen versehen.
+
MapPopulators implementieren entweder die Basisschnittstelle <code>[http://doc.octoawesome.net/api/develop/OctoAwesome.IMapPopulator.html IMapPopulator]</code> oder erben von der Basisklasse <code>[http://doc.octoawesome.net/api/develop/OctoAwesome.MapPopulator.html MapPopulator]</code>. Sie dienen dazu, automatisch in der Welt (unabhängig von der Generierung) Dinge zu platzieren, z.B. Bäume oder Tiere.
  
==Baumtypen==
+
<code>Order</code> definiert die Reihenfolge, in der die Populatoren auf die Welt angewendet werden. In der Methode <code>Populate()</code> wird ein Chunk mit Dingen versehen.
  
;Benötigte Verweise:
+
===Map Generatoren===
: OctoAwesome.dll
 
: OctoAwesome.Basics.dll
 
;Beispielimplementierung(en):
 
: [https://github.com/OctoAwesome/octoawesome/blob/master/OctoAwesome/OctoAwesome.Basics/Definitions/Trees/CactusTreeDefinition.cs CactusTreeDefinition.cs auf GitHub]
 
  
Blocktypen implementieren entweder die Basisschnittstelle <code>[http://doc.octoawesome.net/master/html/T_OctoAwesome_Basics_ITreeDefinition.htm ITreeDefinition]</code> oder erben von der Basisklasse <code>[http://doc.octoawesome.net/master/html/T_OctoAwesome_Basics_TreeDefinition.htm TreeDefinition]</code>.
+
;Beispielimplementierung:
 +
: [https://github.com/OctoAwesome/octoawesome/blob/feature/entities/OctoAwesome/OctoAwesome.Basics/ComplexPlanetGenerator.cs ComplexPlanetGenerator.cs auf GitHub]
  
Über <code>MinTemperature</code>, <code>MaxTemperature</code> und <code>GetDensity()</code> werden die Minimal-/Maximaltemperaturen für diesen Baum und die Häufigkeit des Auftretens ermittelt. In der Methode <code>Init()</code> können die benötigten Blocktypen herausgesucht werden und dann schließlich in der Methode <code>PlantTree()</code> zum "Pflanzen" eines Baumes verwendet werden.
+
Map Generatoren müssen die Schnittstelle <code>[http://doc.octoawesome.net/api/develop/OctoAwesome.IMapGenerator.html IMapGenerator]</code> implementieren.
  
==Texturepacks==
+
Zur Zeit werden die vorhandenen MapGeneratoren aus den Erweiterungen nicht berücksichtigt.
  
Wenn einem die Texturen einer Erweiterung nicht gefallen, muss man nicht sofort eine eigene Erweiterung erstellen. Häufig reicht dafür ein Texturepack aus.
+
==ResourcePacks==
  
Man sollte eine Kopie des <code>Assets</code>-Ordners der entsprechenden Erweiterung kopieren und kann dann in dieser Kopie Texturen mit Dateien mit ''exakt'' dem gleichen Dateinamen ersetzen. Wenn man diesen Ordner dann wieder über das Original drüberkopiert (oder direkt am Original arbeitet), sind die Texturen ersetzt. Wenn man davor den alten Ordner umbenennt kann man sogar wieder zurückwechseln. Man sollte aber darauf achten, dass die neuen Texturen ''genau'' die selben Abmessungen haben, wie die alten.
+
[[Datei:Assets-pipeline.png|thumb|700px|Ladereihenfolge für Assets]]
  
<!--==Map Generatoren==
+
Wenn einem die Texturen einer Erweiterung nicht gefallen, muss man nicht sofort eine eigene Erweiterung erstellen. Häufig reicht dafür ein ResourcePack aus.
  
;Benötigte Verweise:
+
Ein ResourcePack ist ein eigener Unterordner im Ordner <code>Resources/</code>. In diesem Ordner kann optional eine Info-Datei mit dem Namen <code>packinfo.xml</code> angelegt werden, diese Informationen werden im Spiel angezeigt. Zum Aufbau dieser Datei siehe den Link unten.
: OctoAwesome.dll
 
;Beispielimplementierung(en):
 
: [https://github.com/OctoAwesome/octoawesome/blob/master/OctoAwesome/OctoAwesome.Basics/DebugMapGenerator.cs DebugMapGenerator.cs auf GitHub]
 
  
Map Generatoren müssen die Schnittstelle <code>[http://doc.octoawesome.net/master/html/T_OctoAwesome_IMapGenerator.htm IMapGenerator]</code> implementieren.
+
Im Ordner des ResourcePacks werden zu ersetzende Resourcen in Unterordnern gespeichert. Die Ordnernamen entsprechen dabei den Namespacenamen der ladenden Komponente oder Klasse (mit <code>/</code> statt <code>.</code>).
  
Zur Zeit werden die vorhandenen MapGeneratoren aus Erweiterungen nur bedingt berücksichtigt.-->
+
; Beispieldateien:
 +
: [https://github.com/OctoAwesome/octoawesome/blob/develop/OctoAwesome/OctoAwesome.Community/Resources/TomTexturePack/packinfo.xml packinfo.xml]
 +
: [https://github.com/OctoAwesome/octoawesome/tree/develop/OctoAwesome/OctoAwesome.Community/Resources/TomTexturePack Ordnerstruktur]

Aktuelle Version vom 26. September 2018, 19:22 Uhr

Diese Seite bedarf einer Überarbeitung, da sie unvollständig oder fehlerhaft ist. Näheres ist auf der Diskussionsseite angegeben. Hilf mit, sie zu verbessern, vermerke es auf der Diskussionsseite und entferne anschließend diese Markierung. Vielen Dank für Deine Mithilfe!

Dieser Artikel beschreibt den neuen Lademechanismus aus dem Branch feature/entities

In diesem Artikel geht es um das Entwickeln von eigenen Erweiterungen für das Projekt OctoAwesome, nicht um das Verwalten dieser.

Erweiterungen erstellen

Erweiterungen müssen in allen Fällen eine eigene .dll Dateien sein, die entweder direkt im Programmverzeichnis oder im Unterverzeichnis Plugins liegen müssen. Zur Entwicklung verwendet man am besten VisualStudio oder MonoDevelop. Der Namespace- und Assemblyname sollte im Format OctoAwesome.* oder OctoAwesome.Plugin.* sein. In einer einzelnen Erweiterung können mehrere erweiternde Typen definiert sein.

Eine Erweiterung ist eine Klasse, die von IExtension abgeleitet ist. Alle solchen Klassen werden beim Programmstart geladen, wenn der Nutzer sie aktiviert hat. Die Erweiterungsklasse enthält Informationen zur Erweiterung und Code für den Anwendungstart. Darüber können mit dem übergebenen IExtensionLoader einzelne Typen für das Spiel registriert werden:

  • Definitions (= Blocktypen, Items und Baumtypen)
  • Map Populators
  • Map Generatoren (noch keine Auswahl möglich)
  • Entitytypen
  • Extender für Entitäten und die Simulation

Für alle Erweiterungen wird ein Verweis auf OctoAwesome.dll benötigt.

Beispielimplementierung
Extension.cs auf GitHub

Die Dokumentation zu den einzelnen Typen wird zur Zeit überarbeitet und wird in Kürze wieder online sein.

Definitonstypen

Beispielimplementierungen
Blocktyp (GrassBlockDefintion.cs) auf GitHub
Item (WauziEggDefinition.cs) auf GitHub
Baumtyp (CactusTreeDefintion.cs) auf GitHub

Mit einer Defintion wird dem Spiel ein neues Spielelement definiert. Dabei gibt es bisher drei mögliche Definitionstypen.

Blocktypen

Blocktypen implementieren entweder die Basisschnittstelle IBlockDefinition oder erben von der Basisklasse BlockDefinition. Der Vorteil der Basisklasse ist, dass sie bereits viel Standardcode enthält, der nicht in jeden Blocktyp kopiert werden muss.

Die Texturen des Blocks werden als Array von Asset-Referenzen (ohne Dateiendung) dem Spiel übergeben. Diese müssen als Bilddatei mit dem gleichen Namen (aber mit Dateiendung) als Eingebettete Ressource im Ordner Assets des jeweiligen Assemblies liegen. Als Unterordner müssen die Namespacenamensteile (jeder Punkt trennt ein Verzeichnis) ohne den Assemblynamen am Anfang verwendet werden. Hat z.B. ein XYZBlock den Namespacenamen OctoAwesome.XYZ.Blocks aus dem Assembly OctoAwesome.XYZ und verwendet die Textur xyz, so muss die Texturdatei den Pfad ${PROJEKTVERZEISCHNIS}/Assets/Blocks/xyz.png haben. Alternativ können auch jpg oder bmp Dateien verwendet werden.

Die Methoden GetProperties() und Hit() müssen zwar implementiert werden, werden aber nicht vom Spiel verwendet. Das Icon und der Name werden im Spiel angezeigt, aber nicht zur internen Identifikation eingesetzt, können also lokalisiert werden.

Baumtypen

Als weiterer Verweis muss ein Verweis auf OctoAwesome.Basics.dll hinzugefügt werden.

Baumtypen implementieren entweder die Basisschnittstelle ITreeDefinition oder erben von der Basisklasse TreeDefinition.

Über MinTemperature, MaxTemperature und GetDensity() werden die Minimal-/Maximaltemperaturen für diesen Baum und die Häufigkeit des Auftretens ermittelt. In der Methode Init() können die benötigten Blocktypen herausgesucht werden und dann schließlich in der Methode PlantTree() zum "Pflanzen" eines Baumes an der angegebenen Position verwendet werden.

Map Populators

Beispielimplementierung
TreePopulator.cs auf GitHub

MapPopulators implementieren entweder die Basisschnittstelle IMapPopulator oder erben von der Basisklasse MapPopulator. Sie dienen dazu, automatisch in der Welt (unabhängig von der Generierung) Dinge zu platzieren, z.B. Bäume oder Tiere.

Order definiert die Reihenfolge, in der die Populatoren auf die Welt angewendet werden. In der Methode Populate() wird ein Chunk mit Dingen versehen.

Map Generatoren

Beispielimplementierung
ComplexPlanetGenerator.cs auf GitHub

Map Generatoren müssen die Schnittstelle IMapGenerator implementieren.

Zur Zeit werden die vorhandenen MapGeneratoren aus den Erweiterungen nicht berücksichtigt.

ResourcePacks

Ladereihenfolge für Assets

Wenn einem die Texturen einer Erweiterung nicht gefallen, muss man nicht sofort eine eigene Erweiterung erstellen. Häufig reicht dafür ein ResourcePack aus.

Ein ResourcePack ist ein eigener Unterordner im Ordner Resources/. In diesem Ordner kann optional eine Info-Datei mit dem Namen packinfo.xml angelegt werden, diese Informationen werden im Spiel angezeigt. Zum Aufbau dieser Datei siehe den Link unten.

Im Ordner des ResourcePacks werden zu ersetzende Resourcen in Unterordnern gespeichert. Die Ordnernamen entsprechen dabei den Namespacenamen der ladenden Komponente oder Klasse (mit / statt .).

Beispieldateien
packinfo.xml
Ordnerstruktur