Lite-C/Workshop1 03 Panels Strings Text
Grundlagenkurs 
| |
|---|---|
| Autor | Espér |
| Thematik | Lite-C |
| Vorraussetzungen | Programme: 3DGS Trial-Version Free Edition |
| Andere Teile | |
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.
Inhaltsverzeichnis
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.
#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; }
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:
//========================================================================================== //////////////////////////////////////////////////////////////////////////////////////////// // // 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; }
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.
[...] //========================================================================================== //////////////////////////////////////////////////////////////////////////////////////////// // // Panels // //////////////////////////////////////////////////////////////////////////////////////////// PANEL* name = [...]
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:
[...] //========================================================================================== //////////////////////////////////////////////////////////////////////////////////////////// // // Panels // //////////////////////////////////////////////////////////////////////////////////////////// PANEL* testpanel = { pos_x = 10; pos_y = 10; } [...]
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:
[...] //========================================================================================== //////////////////////////////////////////////////////////////////////////////////////////// // // Panels // //////////////////////////////////////////////////////////////////////////////////////////// PANEL* testpanel = { pos_x = 10; pos_y = 10; layer = 1; flags = SHOW; } [...]
layer => Ebenen reichen von -99999 - 99999. Alle minuwerte werden unter den modellen angezeigt ( Quasi als Hintergrund )
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.
[...] //========================================================================================== //////////////////////////////////////////////////////////////////////////////////////////// // // Panels // //////////////////////////////////////////////////////////////////////////////////////////// PANEL* testpanel = { pos_x = 10; pos_y = 10; digits(0, 0, 5, *, 1, testvariable); layer = 1; flags = SHOW; } [...]
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.
digits(X, Y, Format, Font, Faktor, Variable);
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:
[...] //========================================================================================== //////////////////////////////////////////////////////////////////////////////////////////// // // 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; } [...]
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:
//========================================================================================== //////////////////////////////////////////////////////////////////////////////////////////// // // Funktionen // //////////////////////////////////////////////////////////////////////////////////////////// function test() { beep(); testvariable = 999; }
Unsere Funktion. jetzt erstellen wir mal ein Panel darin.
//========================================================================================== //////////////////////////////////////////////////////////////////////////////////////////// // // Funktionen // //////////////////////////////////////////////////////////////////////////////////////////// function test() { beep(); testvariable = 999; PANEL* testpanel2 = pan_create("",1) }
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:
//========================================================================================== //////////////////////////////////////////////////////////////////////////////////////////// // // 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) }
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:
PANEL* name = {Paramater1; Parameter2; Parameter3; ...} PANEL* name = pan_create("Paramater1; Parameter2; Parameter3; ...",Layer) }
Bitmaps
So denn, ich glaube ihr seid auf den Geschmack gekommen ^^
na dann.. auf.. shcnell weiter mit den Bitmaps. Bitmaps sind Bilddateien, welche ihr entweder zur Laufzeit erstellen, oder ins Spiel laden könnt. Bitmaps, die zur laufzeit erstellt wurden, sind lediglich schwarz. Geladene Bitmaps können alles mögliche sein. Unterstützt werden folgende Formate:
- *.bmp
- *.jpg
- *.png
- *.tga
- *.PCX
- *.PSD ( nur mit Plugin )
- *.TCI ( nur mit Plugin )
Achtet also darauf, dass eure Grafiken in diesem Format sind.
Also dann, lasst uns eine bitmap erzeugen. kopiert einfach mal irgendein bild von eurem Computer, in den Projektordner.
Mein bild heißt: testbild.png
ich werde mit diesem Name weitermachen. Ihr müsst dann halt euren Bildname einbaun. So, erstellen wir eine Bitmap:
//========================================================================================== //////////////////////////////////////////////////////////////////////////////////////////// // // Definitionen und Includings // //////////////////////////////////////////////////////////////////////////////////////////// #include <acknex.h> #include <default.c> var testvariable = 3; BMAP* testbmap = "testbild.png";
Super, die Bitmap ist registriert. macht mal einen Testlauf. Sollte nun ein Fehler kommen der besagt, dass er euer Bild nicht finden kann, habt ihr es entweder im falschen Format - oder nicht mit dem Script im selben Ordner.
Sollte dieser Fehler nicht erscheinen, seht ihr.. nix.. Warum?
Weil ihr die Bitmap zwar registriert habt, aber nicht anzeigen lasst.
Also zurück zu unserem Panel:
[...] //========================================================================================== //////////////////////////////////////////////////////////////////////////////////////////// // // Panels // //////////////////////////////////////////////////////////////////////////////////////////// PANEL* testpanel = { pos_x = 10; pos_y = 10; layer = 1; flags = SHOW; } [...]
Ich habe mal alles unnötige entfernt. Und jetzt, kommt die Bitmap rein:
[...] //========================================================================================== //////////////////////////////////////////////////////////////////////////////////////////// // // Panels // //////////////////////////////////////////////////////////////////////////////////////////// PANEL* testpanel = { pos_x = 10; pos_y = 10; bmap = testbmap; layer = 1; flags = SHOW; } [...]
Habt ihr es so eingebaut, dann speichert mal und startet einen Testlauf.
TADAAAA!
Das Bild wird an stelle des Panels angezeigt. Gratulation. Ihr könnt nun zahlen, kleinere Texte und Bilder anzeigen.
Doch wie erstellt ihr nun eine Grafik zur Laufzeit???
BMAP* testbmap = "testbild.png";
ändert dieses mal zu folgendem ab:
BMAP* testbmap = NULL;
Damit habt ihr eine leere Bitmap erstellt.
nun zu unserer Funktion:
//========================================================================================== //////////////////////////////////////////////////////////////////////////////////////////// // // Funktionen // //////////////////////////////////////////////////////////////////////////////////////////// function test() { beep(); testvariable = 999; }
wir erstellen nun die Bitmap:
//========================================================================================== //////////////////////////////////////////////////////////////////////////////////////////// // // Funktionen // //////////////////////////////////////////////////////////////////////////////////////////// function test() { beep(); testvariable = 999; testbmap = bmap_create("testbild.png"); }
fertig...
Ihr habt eine Bitmap zur Laufzeit erstellt.
Hier nochmals die Bitmap Syntax:
BMAP* name = "Dateiname.Endung"; bmap = name; name = bmap_create("Dateiname.Endung");
Das Nachwort "Panels"
Natürlich wollt ihr Panels nicht immer anzeigen. Deswegen gibt es die schöne "flags" Funktion.
UM.. ein panel unsichtbar starten zu lassen:
PANEL* testpanel = { pos_x = 10; pos_y = 10; layer = 1; }
UM.. ein panel SICHTBAR starten zu lassen:
PANEL* testpanel = { pos_x = 10; pos_y = 10; layer = 1; flags = SHOW; }
UM.. ein sichtbares panel unsichtbar zu machen:
reset(panelname,SHOW);
UM.. ein unsichtbares panel sichtbar zu machen:
set(panelname,SHOW);
UM.. Ein panel faden zu lassen, müsst ihr dessen alphawert ändern:
panelname.alpha = wert
Wert ist eine Zahl von 0 (unsichtbar) <-> 100 (sichtbar)
Das sind nur einige der Funktionen. Doch vorerst sollen es eure wichtigsten sein.
STRINGS
Strings sind unsere wichtigste Option um texte in ein Spiel oder Programm zu integrieren. Und so wird ein String definiert:
STRING* name = "";
Dies erzeugt einen String Pointer mit bestimmtem name und ohne inhalt. Lasst uns einmal 50 Leerzeichen eisnetzen.
STRING* name = " ...";
LAAAAANGWEILIG. Darum haben wir dafür einen schnelleren weg. ich bezeichne ihn einmal als "#n" "n" ist hierbei die anzahl der Leerzeichen.
STRING* name = "#50";
Das wars schon.
Strings einbinden
Erinnert ihr euch an die digits. GENAU - diese kleinen codes um Zahlen in einem panel anzuzeigen. Diesen können wir auch verwenden um Text in einem panel anzuzeigen. Dazu verwenden wir einen Format Text.
STRING* name = "ZUVIELE!"; FONT* arial = "Arial#b20"; var prozenter = 99.9; PANEL* testpanel = { pos_x = 10; pos_y = 10; layer = 1; digits(0,0,"Prozent: %s", arial, 1, name); flags = SHOW; }
Der kleine Format Operator "%s" ermöglicht es uns statt einer Variable, einfach einen String in das Digit einzubinden.
Strings verändern
Es gibt viele Wege einen String zu verändern. A8 und Lite-C bieten uns hierführ viele Funktionen. Diese MÜSSEN alle in einer Funktion aufgerufen werden. Hier die wichtigsten:
| Code | Info |
STRING* name = "#20"; name = str_create("#50"); |
Erstellt einen neuen String zur Laufzeit. Der ehemalige Inhalt wird dabei überschrieben. |
STRING* name = "#20"; str_cpy(name, "Neuer String"); |
kopiert den Inhalt eines neuen Strings oder "Texts" in einen anderen. Der erste String wird dabei komplett überschrieben! |
STRING* name = "#20"; str_cat(name, "Neuer String"); |
Hängt den Inhalt des 2. Strings an das Ende des Ersten an. |
STRING* name = "#20"; var lenght = str_len(name); if(str_len(name) > 12) |
Gibt die Zeichenanzahl der im String vorhandenen zeichen zurück, und speichert sie in einer Variable. |
STRING* name = "#20"; var breite = str_width(name, FONT*); if(str_width(name, FONT*) > 256) |
Gibt die Pixelbreite des Strings mit angegebenem Font zurück, und speichert sie in einer Variable. |
STRING* name = "#20"; if(str_cmpi(name, "Neuer String")); |
Fragt ab ob String 1 und 2 GLEICH sind. Er gibt dabei 1 zurück falls ja, und 0 falls nein. Groß- und Kleinschreibung werden hierbei NICHT berücksichtigt. |
STRING* name = "#20"; str_clip(name, Menge); |
Trennt die angegebene Anzahl an Zeichen vom Beginn des Strings ab |
STRING* name = "#20"; str_trunc(name, Menge); |
Trennt die angegebene Anzahl an Zeichen vom Ende des Strings ab |
Es gibt noch weißt mehr String Manipulationen. Doch das waren die wichtigsten.
