Dienstag, 24. Dezember 2013

Frohe Weihnachten

Allen eine frohe Weihnacht, auf das jeder reichlich Geschenke bekommt ;)

Weihnachten steht vor der Tür,
aus diesem Grunde sind wir hier.
Um Dir zu schenken Dein Weihnachtspräsent,
eine große Freude für Dich am vierten Advent.
So pack es nun aus und erfreu Dich am Router,
Du als Informatiker weißt: Dies ist ein guter!


mfg
Hauke

Samstag, 21. Dezember 2013

Die wichtigsten Controls sind fertig

Endlich habe ich die Scrollbar und die Liste fertig. Zum Schluss galt es noch beides zu verbinden, was aber nicht so schwer war ( ist halt gut programmiert ;) ).
Davor hatte ich dann schon das Label und die CheckBox fertig, wollte aber alles in einen Post unterbringen. Mir ist dann ( als ich den Post soweit fertig hatte ) eingefallen, dass ich die Input-Box ganz verbessen hatte ;) , die hab ich dann auch noch schnell gemacht.


List-Control 


Aufbau:
  • Jede Zeile ist unterstrichen
  • Kein automatischer Umbruch ( bei zu langen Zeilen )
    • evtl. später
Methoden ( public ):
  • ListBox(...);
    • verschiedene Parameter stehen bereit
  • void Update(GameTime gameTime);
  • void Draw();
  • void Add(String);
  • void Delete(String);
    • noch nicht implementiert, da ich noch gucke, wie ich das am besten mache ( nach Eintrag suchen, oder statt den Eintrag als String doch lieber die Zeile als Integer übergeben ...)
Liste erstellen:

public ListBox(Window windowHandle, String Title, Rectangle position, Texture2D Texture, SpriteFont Font, Color fontColor, SpriteBatch spriteBatch)
public ListBox(Window windowHandle, String Title, Rectangle position, Texture2D Texture, Color fontColor, SpriteBatch spriteBatch)
public ListBox(Window windowHandle, String Title, Rectangle position, Texture2D Texture, SpriteFont Font, SpriteBatch spriteBatch)
public ListBox(Window windowHandle, String Title, Rectangle position, Texture2D Texture, SpriteBatch spriteBatch)
public ListBox(Window windowHandle, String Title, Rectangle position, Color fontColor, SpriteBatch spriteBatch)
public ListBox(Window windowHandle, String Title, Rectangle position, SpriteFont Font, SpriteBatch spriteBatch)
public ListBox(Window windowHandle, String Title, Rectangle position, SpriteBatch spriteBatch)
public ListBox(Window windowHandle, Rectangle position, SpriteBatch spriteBatch)


Label-Control


Aufbau:
String an bestimmter Position zeichnen, fertig ;)

Methoden ( public ):
  • Label(...);
    • verschiedene Parameter stehen bereit
  • void Draw();
Label erstellen:

public Label(Window windowHandle, String text, Vector2 Position, SpriteBatch spriteBatch, SpriteFont font, Color color)
public Label(Window windowHandle, String text, Vector2 Position, SpriteBatch spriteBatch, SpriteFont font)
public Label(Window windowHandle, String text, Vector2 Position, SpriteBatch spriteBatch, Color color)
public Label(Window windowHandle, String text, Vector2 Position, SpriteBatch spriteBatch)


Scrollbar-Control


Aufbau:
Erzeugt ein Scrollbalken, der unabhängig von einem anderen Control dargestellt wird.

Methoden ( public ):
  • ScrollBar(Rectangle Position, int ReferenceHeight, SpriteBatch spriteBatch);
  • void Update(GameTime gameTime);
  • void Draw();
  • void SetReferenceHeight(int ReferenceHeight);
ReferenceHeight:
Dieser Wert gibt an, wie hoch der Bereich ist, auf den die Scrollbar Einfluss nehmen soll.
  • Bsp.: Ich habe eine Liste, die 300 Pixel hoch ist. Die Einträge alle untereinander gezeichnet sind aber 500 Pixel hoch, so ist meine Referenz-Höhe ( ReferenceHeight ) 500. 
Das Scrollbar-Control erstellt nun ausgehen von diesem Wert die Höhe des Balkens.

Auslesen des Balkens:
Die Position des Balkens ( die Y-Position ) bestimmt schließlich die hoch der Referenzbereich ( also z.B. der Listeninhalt ) hoch/runter geschoben werden soll. Hierzu wird die Höhe nicht in Pixel, sondern als Dezimalzahl zwischen 0 und 1 angegeben. Bei 0 befindet sich der Balken ganz oben, bei 1 ganz unten, bei 0,5 somit genau in der Mitte.
Die Verschiebung muss dann im Code des Referenz-Controls ( z.B. der Liste ) stattfinden.
Setzen kann man diese Höhe mit dem Befehl: SetReferenceHeight(int ReferenceHeight);

Scrollbar erstellen:

public ScrollBar(Rectangle Position, int ReferenceHeight, SpriteBatch spriteBatch)


CheckBox-Control


Aufbau:
Stellt eine typische Checkbox dar, die den Zustand "gecheckt" oder "nicht-gecheckt" haben kann.

Methoden ( public ):
  • CheckBox(...);
  • Boolean Hover();
  • Boolean IsPressed();
  • void Draw(); 
Auslesen des Zustandes:
Einfach auf den Boolean Checked zugreifen ( ist public ).
True - ist gecheckt
False - ist nicht gecheckt

Erstellen einer CheckBox:

public CheckBox(Window windowHandle, String text, Rectangle position, SpriteFont font, Texture2D texture, Texture2D texture_point, Color? fontColor, Color? pointColor, Boolean check, SpriteBatch spriteBatch)
public CheckBox(Window windowHandle, String text, Rectangle position, SpriteFont font, Texture2D texture, Texture2D texture_point, Boolean check, SpriteBatch spriteBatch)
public CheckBox(Window windowHandle, String text, Rectangle position, SpriteFont font, Color? pointColor, Color? fontColor, Boolean check, SpriteBatch spriteBatch)
public CheckBox(Window windowHandle, String text, Rectangle position, SpriteFont font, Boolean check, SpriteBatch spriteBatch)
public CheckBox(Window windowHandle, Rectangle position, Texture2D texture, Texture2D texture_point, Color? fontColor, Color? pointColor, Boolean check, SpriteBatch spriteBatch)
public CheckBox(Window windowHandle, Rectangle position, Texture2D texture, Texture2D texture_point, Boolean check, SpriteBatch spriteBatch)
public CheckBox(Window windowHandle, Rectangle position, Color? pointColor, Color? fontColor, Boolean check, SpriteBatch spriteBatch)
public CheckBox(Window windowHandle, Rectangle position, Boolean check, SpriteBatch spriteBatch)


Input-Control


Aufbau:
Stellt ein Eingabefeld dar, in dem man bisher alle Buchstaben ( groß & klein, inkl. Umlaute ), alle
Zahlen, sowie die meisten Sonderzeichen der deutschen Standard-Tastatur eingeben kann.

Methoden ( public ):
  • Input(...);
  • void Update(GameTime gameTime);
  • void Draw();
  • void SetPosition(Rectangle newPosition);
  • void SetState(Boolean newState); // (De-)aktiviert das Feld
Auslesen der Eingabe:
Es steht einer anderen Klasse der String Text zur Verfügung, dieser beinhaltet die Eingabe.

Erstellen eines Input-Feldes:

public Input(Window windowHandle, Rectangle Position, String Text, SpriteBatch spriteBatch)
public Input(Window windowHandle, Rectangle Position, String Text, Boolean Enabled, SpriteBatch spriteBatch)
public Input(Window windowHandle, Rectangle Position, String Text, Boolean Enabled, Color color, SpriteBatch spriteBatch)
public Input(Window windowHandle, Rectangle Position, String Text, Boolean Enabled, Color color, Texture2D texture, SpriteBatch spriteBatch)
public Input(Window windowHandle, Rectangle Position, String Text, Boolean Enabled, Texture2D texture, SpriteBatch spriteBatch)


Was als nächstes kommt


  • Evtl. mehrzeilige Input-Felder
  • Kleinigkeiten
    • Nicht endlos kleine ScrollBar-Balken ( ist theoretisch möglich ;) )
    • Löschen von Listeneinträgen
Ich hoffe ihr findet die Controls mit den Texturen soweit ganz gut ( mir gefallen sie wohl, hab auch immer mal wieder Kleinigkeiten an den Grafiken gefeilt ).
Falls ihr Ideen, Anmerkungen, etc. hab schreibt mit ruhig Kommentare oder eine E-Mail ( s. Kontakt ).

mfg
Hauke

Ps.: Das ist der 100ste Post auf diesem Blog^^ 

Samstag, 16. November 2013

Buttons fertig

So, hier also ein kleiner Bericht über die momentane Entwicklung.

Ich habe soweit die Buttons fertig :)
Von Aussehen passt alles schon mal, man hat zudem verschiedene Möglichkeiten das Aussehen manuell zu ändern.

Mögliche manuelle Anpassungen der Buttons:
  • eigene Schriftarten
    • über button.Font = ...;
    • auch über den Konstruktor anpassbar
  • spezielle Schrift- & Hintergrundfarbe
    • über button.fontColor = new Color(...);
      ( Schriftfarbe )
    • über button.bkgColor = new Color(...);
      ( Hintergrundfarbe )
    • auch über den Konstruktor anpassbar
  • eigene Textur
    • nur über button.texture = ...; anpassbar
Bisher enthaltene Methoden:
public Boolean Hover(){ }
    // Prüft ob die Maus über dem Button ist
public Boolean IsPressed(){ }
    // Prüft ob der Button gedrückt wurde
public void Draw(){ }
    // Zeichnet den Button

Verbindung Control - Fenster:
Ich habe mich dann gefragt wie ich es hinkriege, dass ein Control quasi zum Fenster gehört. Das wollte ich so haben, weil ich dann nur sagen muss window.Draw(); und das Fenster dann "sein" Controls selbst zeichnen soll. Dadurch muss ich nicht Button1.Draw(); Button2.Draw() ... machen.

Ich habe also eine Liste erstellt, in der nur Buttons gespeichert werden, somit kann ich ganz einfach Methoden der Buttons aufrufen.
Zudem habe ich jedem Buttons das Fenster-Handle zugewiesen, auf dessen Fenster es sich gerade befindet.

public class Window
{
    public List<Button> Button = new List<Button>();
    // ... ( Andere Variablen, Konstruktor, etc. )
    public void Draw()
    {
        // Erst Fenster ansich zeichnen
        for (int i = 0; i < Button.Count; i++)
        {
            Button[i].Draw();
        }
    }
}
public class Button
{
    Arengu game;
    // ...
    public Button(Arengu winHandle, ...)
    {
        this.game = winHandle;
    }
}

Somit kann ich vom Fenster aus Button-Methoden aufrufen und umgekehrt.

Hier ein Bild, wie es im Spiel aussehen wird:

Was als nächstes kommt ( allgemein ):
  • Hauptmenü
    • Liste im Spiel-laden Menü
  • Neue Controls
    • Label
    • Liste ( mit Scrollbalken )
    • Evtl.: CheckBoxen
mfg
Hauke

Sonntag, 10. November 2013

Fenster Management funktionsfähig

So, endlich funktioniert alles wie es soll!
Ich habe die letzten Tage damit verbracht mir Grafiken für die Spiel internen Fenster auszudenken und diese pixelgenau zeichnen zu lassen. Das war zwar einfach, aber mit einer Menge Arbeit verbunden.

Das Tileset:
Damit ich möglichst wenig Bilder nachher habe, habe ich es so gemacht, dass ich alle benötigten Texturen für die Fenster in eine Datei gepackt habe und XNA ( bzw. der "WindowManager" ) sucht sich dann die passenden heraus.

Alle bisher benötigten Texturen.
Button, etc. kommen noch dazu.
Ich habe dann für die Positionen der einzelnen Elemente eine eigene kleine Datei angelegt, wo dann alle Positionen drin stehen:
Rahmen_links,0,0,9,500
Rahmen_rechts,9,0,9,500
Rahmen_oben,18,0,500,9

Rahmen_unten,18,9,500,9
Rahmen_Ecke,18,18,64,64
Ecke_BKG,82,18,72,72
Close_Selected,154,18,56,56
...
Auf diese Weise kann man einfach die Positionen ändern, da auch  immer dabei steht wofür diese Koordinaten stehen.

Hier nun das Ergebnis:
Beispiel Fenster - So sieht es später aus
( Control kommen noch dazu )
Die Symbole in den Ecken haben natürlich alle eine Bedeutung:
  • Rune oben links: Steht für das Runen-System in Arengu und die damit verbundene Magie
  • Schwert und Schaufel oben rechts
    • Steht für die Soldaten / den Krieg und die bäuerlichen Verhältnisse in der Bevölkerung
    • Dient als "Schließen" Button ( wenn man darauf geht, wird der rote Schein stärker )
  • Schwarze Krone unten links: Steht für den König im nördlichen Königreich
  • Goldene Krone unten rechts: Steht für den König im südlichen Königreich
Bitte schreibt doch als Kommentar, wie ihr dieses Beispiel Fenster findet und was ich eventuell noch ändern sollte.

Was jetzt noch kommt, sind:
  • Button
  • Label ( mit verschiedenen Schriftwarten )
  • Input Felder
Warum keine WindowsForms Elemente?
Weil ich gerne alles variabel haben möchte, sprich ich möchte sagen können, dass auch die einzelnen Controls eine bestimmt Textur oder gar eine Animation tragen sollen. Außerdem möchte ich lieber ohne Ereignisse zur Abfrage verschiedener Aktionen auskommen, da mir persönlich Ereignisse nicht so liegen ;).

mfg
Hauke



Freitag, 25. Oktober 2013

Das eigentliche Spiel angefangen

Hallo zusammen,

wie der Titel schon sagt, haben Hendrik und ich das eigentliche Spiel angefangen. Es stehen zwar erst ein paar Zeilen Code, aber die funktionieren wenigstens schon ;)

Beginnen tun wir mit dem Hauptmenü, da wir damit dann schon wichtige Klassen ( ScreenManager ( s.u. ), WindowManager ( s.u. ), etc. ) gleich mit einbringen können.
Danach machen wir dann das laden der Map und die einzelnen Menüs ( Einstellungen, Laden, Neues Spiel, etc. ). Hendrik arbeitet während dessen am Hauptmenü selbst. Ich habe soweit schon mal den ScreenManager ( s.u. ) gemacht und hänge mich momentan hinter den WindowManager ( s.u. ).

ScreenManager???
Der ScreenManager sorgt dafür, dass immer passende "Fenster" im Spiel gezeichnet werden. So sorgt er z.B. dafür, dass, wenn man auf "Spiel laden" im Hauptmenü klickt, nicht mehr das Hauptmenü gezeichnet wird, sondern dann der passende Dialog zum laden eines Speicherstandes.
Hier ein Beispiel-Code, wie das ganze funktioniert:
( Achtung, der Code ist unvollständig und somit nicht lauffähig! )


namespace Arengu
{
 public class Arengu : Microsoft.Xna.Framework.Game
 {
  public ScreenManager Screen;
  
  public Arengu()
  {
   Screen = new MainMenu();
   Screen.game = this;
   Screen.graphics = graphics;
   Screen.Content = Content;
  }
  protected override void Initialize()
  {
   Screen.Initialize();
  }
  protected override void LoadContent()
  {
   Screen.spriteBatch = spriteBatch;
   Screen.LoadContent();
  }
  protected override void UnloadContent() { }
  protected override void Update(GameTime gameTime)
  {
   Screen.Update(gameTime);
   base.Update(gameTime);
  }
  protected override void Draw(GameTime gameTime)
  {
   Screen.Draw(gameTime);
   base.Draw(gameTime);
  }
 }
 public class ScreenManager
 {
  public Game game;
  public GraphicsDeviceManager graphics;
  public SpriteBatch spriteBatch;
  public ContentManager Content;
  public int width, height;

  public virtual void Initialize() { }
  public virtual void LoadContent() { }
  public virtual void UnloadContent() { }
  public virtual void Update(GameTime gameTime) { }
  public virtual void Draw(GameTime gameTime) { }
 }
 public class MainMenu : ScreenManager
 {
  public MainMenu() { } // Konstruktor Stuff
  public override void Initialize()
  {
   base.Initialize();
  }
  public override void LoadContent() { } // Lädt benötigte Objekte   
  public override void UnloadContent() { }
  public override void Update(GameTime gameTime) // Abfragen, etc.
  {
   base.Update(gameTime);
  }
  public override void Draw(GameTime gameTime) // Alles zeichnen
  {
   spriteBatch.Begin();
   spriteBatch.End();
  }
 }
}

WindowManager???
Der WindowManager sorgt dafür, dass einzelne Elemente eines Fensters bereitgestellt werden und gezeichnet, sowie abgefragt werden ( auf Tastendruck oder Mausklick ).
Geplante Elemente:
  • Buttons
  • Input-Felder
  • Checkboxen
  • Label
  • Evtl. Listen ( wahrscheinlich erst am Ende )

Das momentane Hauptmenü von Arengu.
Im Hintergrund sieht man eine der
vielen Nebelschwaden, die vorbeifliegen

Eine herunter zu ladende Version wird es dann geben, wenn man die ersten Maps laden kann, was jedoch noch ein wenig dauern könnte. Bis dahin, werde ich euch auf dem laufenden halten, was die Funktionen etc. angeht.

mfg
Hauke

Samstag, 19. Oktober 2013

MapEditor Beta: 0.1.4 Erster BugFix

Das fängt ja gut an!
Die manuelle Positionierung von Texturen funktionierte nicht richtig.
Habs schnell behoben und neu für den Blog und auf SourceForge hochgeladen.

Tut mir leid wegen eventueller Frustration :(

mfg
Hauke

Freitag, 18. Oktober 2013

MapEditor Beta: 0.1.4 Zoom und Sprachdateien

Hallo ihr alle da draußen,

schon nach neun Tagen hab ich die neue Version des Map-Editors fertig. Die Fülle an neuen Funktionen hält sich jedoch dementsprechend in grenzen.
Die neuen Features sind:

  • Zoom im Test-Modus implementiert
  • Zoom im Collision-Manager implementiert
  • Sprachdateien implementiert ( momentan nur Deutsch und Englisch )
  • Einstellungsdialog für die Umstellung der Sprache

Sprachdateien erstellen:
Wenn ihr eine andere Sprache außer Englisch und Deutsch könnt, dann wäre es super, wenn ihr eigene Sprachdateien erstellt, das geht relativ einfach. Dadurch können wir ein möglichst breites Publikum ansprechen um viele Leute für unser Projekt zu begeistern. ( hier geht zur Anleitung )

Wie es weiter geht:
Erstmal müssen wir ein wenig planen, wie wir einzelne Sachen genau umsetzen. Dabei geht es vor allem um Interaktionen mit der Spielwelt, also von Quests über einfache Gespräche mit Leuten bis hin zu Kleinigkeiten wie das öffnen einer Truhe oder ähnliches.
Das alles muss geplant werden und dementsprechend der Map Editor angepasst werden. Das ganze werden Hendrik und ich machen, während Sebastian und schöne neue Grafiken macht, die wir dann auch noch in den Map Editor einbringen werden.
Es steht uns also eine Menge Planerei bevor, aber ich werde hoffentlich dran denken immer mal wieder Infos zu posten ( guckt da auch öfters mal bei Twitter nach, da ich dort öfters was poste ).

mfg
Hauke

Mittwoch, 9. Oktober 2013

MapEditor Beta: 0.1.3 Erleichterte Bedienung, mehr Kollisionen, weniger Bugs

Hallo liebe Leute,

endlich ist es mal wieder so weit, die nächste Version des Map-Editor ist da!

Was bietet 0.1.3 an neuen Features?
Zunächst wurden viele Bugs behoben, die in 0.1.2 noch auftraten, was so ziemlich die meiste Zeit in Anspruch genommen hat. Des weiteren habe ich die Bedienung (hoffentlich ;) ) vereinfacht, dadurch, dass ich viele Dinge schneller erreichbar gemacht habe ( z.B. zum löschen einer Textur, kann man sie anwählen und dann einfach "ENTF" drücken, schon ist sie weg ).
Hier ist eine Liste mit allen neue Features ( die Bugs habe ich mal lieber nicht gezählt ;) ):
  • Bedienung
    • Texturen auswählen ( Rechtsklick ) und mit ENTF entfernen
    • Nach Eingabe von Manuellen Verschiebungs-/Skalierungswerten kann man einfach mit ENTER bestätigen ( vorher nur über "OK"-Button )
    • Nachfrage nach dem Drücken des RESET-Buttons ( Ja/Nein Nachfrage )
    • Eingabe von Kommas im Edit-Feld sind möglich
    • Der "Collision: ON/OFF"-Button im "Eigenschaften" Bereich funktioniert endlich
    • Kein Zoom im Test-Modus mehr ( vorläufig, da es nicht richtig funktionierte :( )
  • Anzeige
    •  Im TEX-Modus wird bei verschobenen Texturen der Ursprungsort angezeigt
  • Daten
    • Mehr Kollisionsdaten ( für alle Bäume, das Zelt und den Grabstein )
Das kommt in der nächsten Version:
In der Version 0.1.4 kommen Sprachdateien, das heißt man kann den MapEditor auch in anderen Sprachen anbieten, da ich als Fremdsprache nur Englisch habe ( und nur Englisch und Latein gelernt habe ;) ), biete ist lediglich eine englische Version an. Beschreibung zum erstellen eigener Sprachdateien lege ich jedoch bei, bitte schickt mir die Dateien dann, damit ich sie dann zum Download bereitstellen kann, bzw. sie in der nächsten Version gleich mit einbinden kann!
Des weiteren behebe ich die Fehler beim Zoom im Test-Modus, sodass ihr da wieder Zoomen könnt.
( mehr/aktuellere Infos findet ihr unter "Downloads" bei der jeweiligen Version ).


Zum Downloadbereich
Direktkdownload
Zur SourceForge Seite

Bitte schriebt mir, was nicht funktioniert / was ich besser machen kann ( s. "Kontakt" ).

mfg
Hauke

Dienstag, 6. August 2013

Arengu auf Sourceforge

Um das gesamte Projekt ein wenig zu professionalisieren und es auch ein wenig bekannter zu machen, habe ich mich bei Sourceforge angemeldet und dort dann Arengu eingetragen.


Ändert sich etwas?
Nein.
Alle Versionen können nun sowohl von Sourceforge, als auch vom normalen Arengu-FTP heruntergeladen werden.
Auch wenn man bei Sourceforge einen Blog erstellen kann, werde ich das nicht tun, sondern hier bei Blogspot bleiben.


Hier die wichtigsten Links:
Zum Projekt
Zumden Map-Editor Files

Freitag, 26. Juli 2013

MapEditor Beta: 0.1.2 bietet viele neue Features

Endlich in der Beta:
Der Map-Editor



Wie versprochen hier die Version 0.1.2. Der Map-Editor ist nun in der Beta-Phase, also bitte ich euch alle ihn schon mal zu testen.
Ich weiß, dass das Angebot an Texturen sehr gering ist, dennoch kann man schon mal die ein oder andere kleine Landschaft gestalten.

Direkt zum Download

Bisherige, wichtige Features:
  • Map erstellen, speichern und laden
  • Auswählen von Leveln ( Level sind vergleichbar mit Ebenen in Photoshop/Gimp )
  • Fülleimer und Radiergummi zum erleichterten editieren der Map
  • Individuelles Skalieren von Texturen ( Position und Größe )
  • Test-Modus: Die erstellte Map so, wie sie ist testen und gucken ob alles passt ( NEU )
  • Erweiterte Bedienung durch Tastatur ( s.u.: Steuerung )
Steuerung:
  • Normaler Modus
    • W, A, S, D - Wechseln der Textur um linken Bereich
    • TAB - Level wechseln ( immer einen höher; 6 --> 1 )
    • 1-6 - Level auswählen
    • Linke Maustaste - Textur setzen / Löschen ( zum löschen zuerst auf "Radiergummi" klicken )
    • Rechte Maustaste - Textur markieren ( zum manuellen Editieren im rechten Bereich )
    • Mausrad - Zoom
  • Test-Modus
    • W, A, S, D - Bewegen des Charakters ( hier: rotes Rechteck )
    • ESC - Beenden des Test-Modus
    • Mausrad - Zoom
Beachte:
  • Radiergummi, Fülleimer, sowie die Kombination aus beidem ist nach einmaligem klicken mit der linken Maustaste deaktiviert. 
  • Bei Objekten, bei denen der Spieler vor oder dahinter sein kann, macht es Sinn diese auf Ebene 3 zu platzieren, da auf den anderen Ebenen keine Berechnung dazu stattfindet!
  • Der Netz-Button: Der Netz-Button hat drei Modi ( an, aus & TEX ). Der TEX-Modus Umrahmt nur die auf der ausgewählten Ebene befindlichen Texturen. Umrahmungen der Felder und der Texturen anderer Ebenen werden nicht angezeigt! 
Map-Editor mit TEX-Anzeige ( s.o. ).
Map-Editor im Test-Modus.
Das kommt demnächst:
Als nächstes sind Animationen fällig, da heißt einfach nur, dass man Texturen hat, die ihr Bild nach gewisser Zeit ändern. Hoffentlich ist das einfacher als die Positions-Geschichte :/
Danach werden die hoffentlich reichlichen Rückmeldungen bearbeitet, das heißt Bugs fixen, eventuell neue Funktionen aufnehmen, alte verbessern, etc.

Zum Downloadbereich
Direktkdownload 

Bitte schriebt mir, was nicht funktioniert / was ich besser machen kann.

mfg
Hauke

Donnerstag, 25. Juli 2013

Map-Editor: Ein großer Schritt nach vorne!

Beim Map-Editor habe ich nun eine große Hürde mit viel mathematischer Rechnerei hinter mir:
Die Überprüfung ob der Charakter vor-, oder hinter einem Objekt ( einem Baum, Haus, etc. ) steht. Quasi das 3 dimensionale an unserem 2D Spiel ;).


Wie genau funktioniert das nun?
Es wird zunächst eine Liste erstellt, die nach der Höhe der unteren Kante der Texturen geordnet ist.
Die untere Kante deswegen, weil diese ja quasi den Boden berührt.
Der Spieler bekommt hingegen eine Nummer zugeteilt, die besagt nach der wievielten Textur das Bild des Spielers gezeichnet werden soll.
Beim zeichnen, wird die oben genannte Liste einfach abgearbeitet und der Spieler an der passenden Position dazwischen gezeichnet.

Schwierigkeiten bei der Umsetzung:
Zunächst habe ich versucht einfach die Höhen der unteren Kante in eine Liste einzutragen und die dann per "QuickSort" ( schneller Sortieralgorithmus ) zu sortieren. Dabei hatte ich dann das Problem, dass ich die Nummer der jeweiligen Textur ( jede Textur hat eine eindeutige ID ) nicht mit sortiert wird.
Nach ein paar Anläufen hatte ich es dann soweit, jedoch war die Liste verkehrt herum, sodass die Texturen dementsprechend falsch gezeichnet wurden.
Zunächst hatte ich die Schleifen einfach andersherum laufen lassen ( nicht von 0 bis x, sondern von x bis 0 ), jedoch war das keine optimale Lösung. Nach mehreren Versuchen bin ich dann auf die obige gekommen.

Video:
Hier ein kleines Video, welches zeigt, wie das ganze dann in echt aussieht. Nichts besonderes, es hat aber eine Menge Arbeit gekostet!
Mehr Videos zum Map-Editor gibt es eventuell in Kürze.

Bilder:
Ein paar Bilder zum Map-Editor gibts jedoch schon im Vorraus ;)
Zum Bildarchiv

Version 0.1.2 des Map-Editors:
Nachdem ich ein paar Bugs behoben habe, lade ich die nächste Version des Editors hoch.
Als nächstes kommen dann noch Animationen ( z.B. Lagerfeuer, bewegende Lampen, etc. ), sowie noch kleinere Funktionen, die die Tools ( Füllwerkzeug, Radierer, etc. ) des Editors betreffen.

mfg
Hauke



Mittwoch, 26. Juni 2013

Idee für ein PlugIn-System

Ein netter User hatte die Idee ein PlugIn-System für Arengu einzuführen ( siehe: Kommentare von "Map-Editor: Halbzeit" ).
Die Idee von Plugins gab mir schon seit längerer Zeit ein kleines Rätsel hinsichtlich der Funktionsweise auf, weswegen ich mich ein bisschen näher damit beschäftigt habe und siehe da:
Ich habe nun ein Beispielcode für meine Idee von einem Mini-PlugIn-System hochgeladen.

Meine Vorgehensweise:
Für die DLL gebe ich einen Namespace, einen Klassennamen und einen Methodennamen vor, damit ich ( also das Spiel im Endeffekt ) weiß, was ich ausführen muss.

In eigener Sache:
Bitte schaut es euch an ( sind nur ein paar Zeilen ) und sagt, was ihr davon haltet und was man - mit Sicherheit - verbessern kann. Vielen Dank dafür schonmal.

Download ( 7z - 12,9 MB): arengu.square7.ch/Arengu/ExampleCodes/Reflection.7z

mfg
Hauke

Samstag, 22. Juni 2013

Map-Editor: Halbzeit

So, endlich konnte ich mal wieder richtig an meinem Map-Editor basteln.

Nun ist Halbzeit, was bedeutet, dass ich
ca. die Hälfte von den geschafft habe, was ich schaffen wollte.

Folgende Funktionen gibt es schon:
  • Map erstellen, speichern und laden
  • Auswählen verschiedener Texturen aus verschiedenen Kategorien
  • Auswählen von Leveln ( Level sind vergleichbar mit Ebenen in Photoshop/Gimp )
  • Bereich anzeigen, in die der Spieler nicht gehen kann
  • Fülleimer zum füllen einer ganzen Ebene
  • Raddiergummi zum löschen von Texturen eines Feldes
  • Kombi: Raddierer & Farbeimer 
    • Ganze Ebene wird geleert ( alle Texturen werden entfernt )
  • Skalieren von Texturen ( Position und Größe )
Screenshot der Version 0.1.1 des Map-Editors ( Download )
Folgende Funktionen kommen noch:
  • Test-Modus ( dort hat man einen Beispiel-Charakter, mit dem man dann raumlaufen kann um zu gucken wie es im Spiel aussieht ) - noch viel Arbeit
  • Speichern & laden von Skalierungen
  • Input-Felder für die Eingabe von Dateinamen ( beim speichern und laden )
  • Input-Felder für die Angabe der Mapgröße ( beim erstellen einer neuen Map )
Ihr seht, es gibt also noch einiges zu tun, jedoch ist schon ein ganzes Stück geschafft.
Unter Download ( oben ) findet ihr zudem alle bisher veröffentlichten Versionen des Spiels und dieses Map-Editors.
Alternativ hier der Direkt-Link.

mfg
Hauke

Mittwoch, 22. Mai 2013

Es geht weiter!



Ich habe mich nach einer langen Pause dazu entschlossen Arengu weiter zu machen, bzw. neu an zu fangen.
Statt die momentanen Funktionen und Programme alle nach C# zu portieren, werde ich quasi alles neu schreiben. Story und Aufbau des Spiels kommen ebenfalls neu, was nicht heißt, dass das nochmal Jahre dauert, bis ich wieder soweit bin. C# / XNA ist relativ leicht zu programmieren, macht ( mir ) mehr Spaß als AutoIt und ich für Grafische Sachen einfacher zu "bedienen".

Wann kommt das erste Release?
Gute Frage, nächste Frage! ( = Keine Ahnung ;) )

Woran arbeitest du gerade?
Ich habe mit dem Map-Editor begonnen und werde den auch erstmal zu ende machen. Mehr Infos gibt es dann, wenn man damit schon richtig was anfangen kann.

Was wird sich genau ändern?
Im Prinzip alles. Ich werde natürlich Dinge wie den typischen Laden oder die Scrolls / Medaillen beibehalten, aber vom Design wird sich mit Sicherheit was tun und auch im Gameplay, aber Infos dazu gibt es, wenn es soweit ist.

Im eigener Sache:
  • Ihr könnt euch beim Newsletter ( rechte Leiste ) anmelden um neue Posts nicht zu verpassen.
  • Des weiteren gibt es einen Twitter Account von mir, wo ihr alle kleinen Infos, was das Spiel betrifft nachlesen könnt. Ausführliche Informationen gibts dann immer hier im Blog.
  • Videos und Previews, sowie C# und AutoIt Tutorials gibt es auch auf meinem YouTube-Channel.
Bilder, mehr Infos und Einblicke ins "neue" Arengu gibts dann in ein bis zwei Wochen, seid also gespannt ;)

mfg
Hauke

Samstag, 16. Februar 2013

Entwirrung

Hallo Leute,

mich schreiben immer noch Leute wegen des Spiels an. Hier nun klipp und klar die Botschaft:
Wie lange und OB es ÜBERHAUPT weiter geht weiß ich nicht. Ich arbeite momentan an einem anderen Projekt ( in C# mit XNA ). Wenn ihr wissen wollt wann es weitergeht, meldet euch doch bei meinem Newsletter an ( rechte Leiste ganz unten ).

Warum?
Weil AutoIt nicht die nötigen Kapazitäten hat um ein ausgereiftes Rollenspiel ausführen zu können. Die Sprache ist eben nicht für Spiele ausgelegt und das merkt man: Die Geschwindigkeit lässt beim Zeichnen deutlich nach.
Vergleich zu XNA:
XNA zeichnet 50.000 Bilder ( 200x200 Pixel ) 11x pro Sekunde ( sprich 550.000 Bilder / Sekunde ). AutoIt braucht für 50.000 Bilder ca. 104 Sekunden. XNA würde in 104 Sekunden also 57.200.000 Bilder zeichnen. Das nur als Geschwindigkeitsvergleich^^.

mfg
Hauke

ps.: Kommentare und Mails werden trotzdem beantwortet!