Quelltext der Seite Lite-C/Workshop1 03 Panels Strings Text

__TOC__
Zeit für den 3. Workshop.
Panels, Strings und Textsyntax sollen heute unser Thema sein. Gleichzeitig zeige ich euch auf, warum ich Variablen und Funktionen vorgezogen habe ( oftmals werden variablen und Panels zuerst erklärt ).

Also dann, beginnen wir.
----

== Vorbereitung ==
Hier gibts nicht viel. übernehmt einfach das schöne Funktionen und Aktionen Script aus dem Variablen Workshop ( das mit der globalen variable ).

Das ist auch der grund, warum variablen und Funktionen zuerst erklärt wurden. Wir haben nun nämlich einen kompletten Funktionsbaum, den wir beliebig in den Workshops verwenden können.

<source lang="c">
#include <acknex.h>
#include <default.c>

var testvariable = 3;

action testaktion()
{
}

function test()
{
  beep();
  testvariable = 999;
}

function main()
{
  video_mode = 6;
  level_load(NULL);
  wait(3);
  test();
  testvariable = 3;
}
</source>

Lasst uns zuerstmal etwas Ordnung in das Script bringen. Dazu bedienen wir uns diverser Kommentarfunktionen.
Hier die wichtigsten:
    //   '''Erstellt einen Kommentar. Alles in der Zeile, das diesem folgt, ist kommentiert'''
    /*   '''Ähnlich dem =begin in RGSS. Alles was folgt ( alle Zeilen ) sind Kommentiert.'''
    */   '''Ähnlich dem =end in RGSS. Hier endet die komplett Kommentierung.'''

Also:
<source lang="c">
//==========================================================================================
////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                          
//                                                 Definitionen und Includings
//                                                                                          
////////////////////////////////////////////////////////////////////////////////////////////
#include <acknex.h>
#include <default.c>

var testvariable = 3;

//==========================================================================================
////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                          
//                                                          Panels
//                                                                                          
////////////////////////////////////////////////////////////////////////////////////////////

//==========================================================================================
////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                          
//                                                         Aktionen
//                                                                                          
////////////////////////////////////////////////////////////////////////////////////////////
action testaktion()
{
}

//==========================================================================================
////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                          
//                                                         Funktionen
//                                                                                          
////////////////////////////////////////////////////////////////////////////////////////////
function test()
{
  beep();
  testvariable = 999;
}

//==========================================================================================
////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                          
//                                                             MAIN
//                                                                                          
////////////////////////////////////////////////////////////////////////////////////////////
function main()
{
  video_mode = 6;
  level_load(NULL);
  wait(3);
  test();
  testvariable = 3;
}
</source>
Ihr könnt es euch natürlich so übersichtlich machen wie ihr wollt.

Wir werden dieses Script nun als Grundlage für weitere Workshops nehmen ( außer ich sag was andres ). 

Ihr solltet es also immer schön bereithalten.
----

== PANELS ==
Zum erstellen eines Panels, benötigen wir wieder einen Vorreiter -  "PANEL*"

'''Wichtig''': vergesst bloß den Stern nicht.
<source lang="c">
[...]
//==========================================================================================
////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                          
//                                                          Panels
//                                                                                          
////////////////////////////////////////////////////////////////////////////////////////////
PANEL* name =

[...]
</source>
Wie ihr seht, schreibe ich erstmal den Grundsyntax hin. Dies hat den Grund, da ein Panel nicht aus ein-zwei Parametern besteht. Es muss mit mehreren Daten gefüttert werden.

Ein panel ist ein layer in eurem Spiel. Ihr könnt darin Bitmaps, Texte, Buttons, Zahlen, windows und sogar Views anzeigen lassen. Daher müssen wir dem panel sagen, wo es sein soll, was es beinhaltet, ob es sichtbar ist, auf welcher Ebene es ist...etc

Legen wir mal die Position des Panels fest. Dies tun wir innerhalb einer geschweiften Klammer nach dem "=" Zeichen:
<source lang="c">
[...]
//==========================================================================================
////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                          
//                                                          Panels
//                                                                                          
////////////////////////////////////////////////////////////////////////////////////////////
PANEL* testpanel =
{
  pos_x = 10;
  pos_y = 10;
}
[...]
</source>
pos_x / pos_y  => '''Legt die X und Y koordinate in Pixeln fest'''

Ich habe das panel nun 10 Pixel vom linken Bildrand nach rechts, und vom oberen Bildrand nach unten verschoben.
'''MERKT EUCH''': Ausgangspunkt für X/Y koordinaten ist immer die linke obere Ecke des Bildschirms.

Gut, sagen wir dem panel nun noch, auf welcher Ebene es stehen soll, und ob es sichtbar sein soll:
<source lang="c">
[...]
//==========================================================================================
////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                          
//                                                          Panels
//                                                                                          
////////////////////////////////////////////////////////////////////////////////////////////
PANEL* testpanel =
{
  pos_x = 10;
  pos_y = 10;
  layer = 1;
  flags = SHOW;
}
[...]
</source>
layer => '''Die Ebene. 0 ist die niedrigste Ebene.'''

flags => '''Dem objekt zugewiesene Schalter. SHOW = von Spielbeginn an sichtbar.'''

Nun haben wir ein Panel erstellt. Da es noch keinen Inhalt hat, wird man bei einem testlauf nix sehen. darum kümmern wir uns doch gleich mal.
<source lang="c">
[...]
//==========================================================================================
////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                          
//                                                          Panels
//                                                                                          
////////////////////////////////////////////////////////////////////////////////////////////
PANEL* testpanel =
{
  pos_x = 10;
  pos_y = 10;
  digits(0, 0, 5, *, 1, testvariable);
  layer = 1;
  flags = SHOW;
}
[...]
</source>
Startet ihr mit diesem Code ein testspiel, wird euch der Inhalt der Testvariable oben Links angezeigt.
Cool oder?

Gut, ich werd euch den "digits" Syntax erklären.
<source lang="c">
digits(X, Y, Format, Font, Faktor, Variable);
</source>
X        => '''X-position in pixel innerhalb des Panels.'''

Y        => '''Y-position in pixel innerhalb des Panels.'''

Format   => '''Entweder eine Zahl, oder Ein Textstring. Bei Zahlen gibt er die Gesamtanzahl der zu zeichnenden Zahlen an. Beispiel:  5.1 zeigt 3 vorkommastellen + 1 dezimalpunkt + 1 nachkommastelle an. Also insgesamt 5 Zeichen. Ihr könnt auch einen Text anzeigen. Einfach "Text" einfügen.'''

Font     => '''Der name eines vorher definierten Fonts muss hier stehen. * ist eine von der Engine vordefinierte Schriftart.'''

Faktor   => '''Der Multiplikationsfaktor der Variable.'''

Variable => '''Der Name der Variable.'''


Das ist nur eine einfache Variante dem Spieler etwas anzuzeigen.

Hier mal ein COdebeispiel ( kommentiert ) was es noch alles gibt:
<source lang="c">
[...]
//==========================================================================================
////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                          
//                                                          Panels
//                                                                                          
////////////////////////////////////////////////////////////////////////////////////////////
PANEL* testpanel =
{
  pos_x = 10;
  pos_y = 10;
  //Zahlen, standardtext anzeigen
  digits(X, Y, Format, Font, Faktor, Variable);
  //Ein bild anzeigen
  bmap = BMAP name
  //Ein regulierbares Fenster innerhalb des Panels erstellen
  window (x, y, x-verschiebung, y-verschiebung, bmap, variableX, variableY);
  //Diverse Buton Funktionen
  button(x, y, bmapOn, bmapOff, bmapOver, functionOn, functionOff, functionOver);
  button_toggle(x, y, bmapOn, bmapOff, bmapOver, bmapOverOff, functionClick, functionLeave,
 functionOver);
  button_radio(x, y, bmapOn, bmapOff, bmapOver, functionClick, functionLeave, functionOver);
  layer = 1;
  flags = SHOW;
}
[...]
</source>
Zu all diesen Funktionen kommen wir aber Später.


Ihr habt also nun die Fähigkeit erworben, ein panel zu erstellen und etwas darin zu zeigen. Glückwunsch.
----

== PANELS on-the-run erzeugen==
Das ist ein sehr wichtiger Punkt. Ihr könnt Panels mit Inhalt sogar innerhalb einer Funktion erstellen.

Dies ist nicht sonderlich kompliziert, hat aber dennoch eine kleine Umstellung vom Aussehen:
<source lang="c">
//==========================================================================================
////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                          
//                                                         Funktionen
//                                                                                          
////////////////////////////////////////////////////////////////////////////////////////////
function test()
{
  beep();
  testvariable = 999;
}
</source>
Unsere Funktion. jetzt erstellen wir mal ein Panel darin.
<source lang="c">
//==========================================================================================
////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                          
//                                                         Funktionen
//                                                                                          
////////////////////////////////////////////////////////////////////////////////////////////
function test()
{
  beep();
  testvariable = 999;
  PANEL* testpanel2 = pan_create("",1)
}
</source>
Also, der Code würde so nicht funktionieren. Ich will damit mal auf die zwei " in der Klammer aufmerksam machen. Dort rein schreiben wir nun unsere Parameter des Panels:
<source lang="c">
//==========================================================================================
////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                          
//                                                         Funktionen
//                                                                                          
////////////////////////////////////////////////////////////////////////////////////////////
function test()
{
  beep();
  testvariable = 999;
  PANEL* testpanel2 = pan_create("pos_x=10;pos_y=10;digits(0, 0, 5, *, 1, testvariable);flags=SHOW;",1)
}
</source>
fertig. ihr habt das Panel nun während der Laufzeit erstellt. Dies ist wichtig falls ihr Buttons, Bilder oder Zahlenausgaben zur Laufzeit erstellen wollt ( neue gebäude erworben..etc ).


Hier nochmals die 2 Grundsyntax für Panels:
<source lang="c">
PANEL* name = {Paramater1; Parameter2; Parameter3; ...}
PANEL* name = pan_create("Paramater1; Parameter2; Parameter3; ...",Layer)
}
</source>




Fortsetzung folgt in:  BITMAPS, TEXTE UND STRINGS
----


----
Zurück zur Grundkursauswahl: [http://www.rpg-studio.de/scientia/Lite-C/Workshop1_Page]