de API
In microStudio wird der Bildschirm durch das vordefinierte Objekt "screen" dargestellt. Um Formen oder Bilder auf dem Bildschirm zu zeichnen, kannst du einfach Funktionen (auch Methoden genannt) von diesem Objekt aufrufen. Zum Beispiel:
screen.setColor("#FFF")
screen.fillRect(0,0,100,100)
Der obige Code definiert die Zeichenfarbe als #FFF, das steht für die Farbe Weiß (siehe Erläuterungen unten). Dann wird ein mit dieser Farbe gefülltes Rechteck gezeichnet. Zentriert auf die Koordinaten 0,0 des Bildschirms (d. h. Mitte des Bildschirms) und mit der Breite 100 und der Höhe 100.
Um dir die Arbeit zu erleichtern, skaliert microStudio die Bildschirmkoordinaten automatisch, unabhängig von der tatsächlichen Bildschirmauflösung. Die kürzeste Seite (Breite im Hochformat, Höhe im Querformat) ist immer auf 200 festgelegt.Der Koordinatenursprung (0,0) ist in der Mitte des Bildschirms. Damit hat die kürzere Seite einen Wertbereich von -100 bis +100. Die längere Seite hat einen Wertebereich von z. B. -178 bis +178 bei einem klassischen 16:9-Bildschirm oder -200 bis +200 bei einem 2:1-Bildschirm, längeren/neueren Smartphones usw..
Koordinatensystem auf einem 16:9-Bildschirm im Hochformat und im Querformat
Definiert die Farbe color, die für die nächsten Zeichenfunktionen verwendet werden soll.
Die Farbe wird durch einen String (Zeichenkette/Text) definiert, also in Anführungszeichen "". Sie wird meistens durch ihre RGB-Komponenten beschrieben, also eine Mischung aus Rot, Grün und Blau. Es gibt mehrere mögliche Formate:
- "rgb(255,255,255)": (rgb für rot, grün, blau). Hier wird ein Wert für Rot, Grün und Blau angegeben, der zwischen 0 und 255 liegt. "rgb(255,255,255)" ergibt Weiß, "rgb(255,0,0)" ergibt Hellrot, "rgb(0,255,0)" ergibt Grün usw. Um eine Farbe einfacher zu ändern, klicke auf die rgb-Farbe und halte die Strg-Taste gedrückt. Dadurch öffnet sich ein Farbwähler (Color Selector).
- "#FFF" oder "#FFFFFF": Dieses Format verwendet Hexadezimalzahlen, um die 3 Komponenten von Rot, Grün und Blau zu beschreiben. Hexadezimalzahlen verwenden 16 Ziffern (anstatt 10 im Dezimalsystem), und zwar 0 bis 9 und A bis F.
- Es gibt noch weitere Formate, die hier aber nicht weiter beschrieben werden.
Löscht den Bildschirm und füllt ihn in der übergebenen farbe. Wenn keine farbe definiert ist, wird er schwarz gefüllt.
Zeichnet eine rechteckige Fläche mit Mittelpunkt an den Koordinaten x und y, mit der gegebenen Breite width und Höhe height. Die Farbe color ist optional. Wenn sie weggelassen wird, wird in der zuletzt verwendeten Farbe gezeichnet.
Zeichnet ein gefülltes, abgerundetes Rechteck mit Mittelpunkt an den Koordinaten x und y, mit der gegebenen Breite width, Höhe height und dem Radius der Ecken radius. Die Farbe color ist optional. Wenn sie weggelassen wird, wird in der zuletzt verwendeten Farbe gezeichnet.
Zeichnet eine runde Fläche (Kreis oder Ellipse) mit Mittelpunkt an den Koordinaten x und y, mit der gegebenen Breite width und Höhe height. Die Farbe color ist optional. Wenn sie weggelassen wird, wird in der zuletzt verwendeten Farbe gezeichnet.
Zeichnet dem Umriss eines Rechtecks mit Mittelpunkt an den Koordinaten x und y, mit der gegebenen Breite width und Höhe height. Die Farbe color ist optional. Wenn sie weggelassen wird, wird in der zuletzt verwendeten Farbe gezeichnet.
Zeichnet dem Umriss eines abgerundeten Rechtecks mit Mittelpunkt an den Koordinaten x und y, mit der gegebenen Breite width, Höhe height und dem Radius der Ecken radius. Die Farbe color ist optional. Wenn sie weggelassen wird, wird in der zuletzt verwendeten Farbe gezeichnet.
Zeichnet den Umriss einer runde Fläche (Kreis oder Ellipse) mit Mittelpunkt an den Koordinaten x und y, mit der gegebenen Breite width und Höhe height. Die Farbe color ist optional. Wenn sie weggelassen wird, wird in der zuletzt verwendeten Farbe gezeichnet.
Zeichnet eine Linie, die die Punkte (x1,y1) und (x2,y2) verbindet. Die Farbe color ist optional. Wenn sie weggelassen wird, wird in der zuletzt verwendeten Farbe gezeichnet.
Zeichnet die Fläche eines Polygons, das durch die übergebenen Punktkoordinaten definiert ist. Die Farbe color ist optional. Wenn sie weggelassen wird, wird in der zuletzt verwendeten Farbe gezeichnet.
Die Funktion akzeptiert auch ein Array als ersten Parameter und eine Farbe als zweiten Parameter. In diesem Fall muss das Array die Koordinaten wie folgt enthalten: screen.fillPolygon( [ x1, y1 , x2, y2, x3, y3 ... ], color ).
Zeichnet den Umriss eines Polygons, das durch die übergebenen Punktkoordinaten definiert ist. Die Farbe color ist optional. Wenn sie weggelassen wird, wird in der zuletzt verwendeten Farbe gezeichnet.
Die Funktion akzeptiert auch ein Array als ersten Parameter und eine Farbe als zweiten Parameter. In diesem Fall muss das Array die Koordinaten wie folgt enthalten: screen.drawPolygon( [ x1, y1 , x2, y2, x3, y3 ... ], color ).
Setzt die Linienbreite (engl. "line width") für alle nachfolgenden Zeichenoperationen (drawLine, drawPolygon, drawRect etc.). Die Standard-Linienbreite ist 1.
Zeichnet ein Sprite (ein Bild), das Du im Abschnitt Sprites erstellt hast. Der erste Parameter ist der Name des Sprites (ein String), z.B. "Icon". Dann folgen die x,y-Koordinaten, wo das Sprite angezeigt werden soll (das Sprite wird auf diesen Koordinaten zentriert). Dann die Breite width und Höhe height, die das Sprite auf dem Bildschirm haben soll.
screen.drawSprite("icon",0,50,50)
Die Höhe 'height` kann, wie im obigen Beispiel, weggelassen werden. In diesem Fall wird die Höhe anhand der Breite und der Proportionen des Sprites berechnet.
Animierte Sprites zeichnen automatisch den richtigen Frame entsprechend der Animationseinstellungen. Du kannst den aktuellen Frame eines Sprites (z.B. um die Animation neu zu starten) folgendermaßen setzen:
sprites["sprite1"].setFrame(0) // 0 ist der Index des ersten Frames
Du kannst auch einen bestimmten Frame deines Sprites zeichnen, indem du "." und den Index des gewünschten Frames anhängst:
screen.drawSprite("sprite1.0",0,50,50)
Das obige Beispiel zeichnet den Frame 0 des Sprites "sprite1".
("part" = "Teil")
Zeichnet einen Teil eines Sprites. Der erste Parameter ist der dem Namen des Sprites (ein String), zum Beispiel "Icon". Die nächsten 4 Parameter definieren die Koordinaten eines Rechtecks innerhalb des Sprites, das tatsächlich auf den Bildschirm gemalt werden soll (Vorsicht: (0,0) ist hier die linke obere Ecke des Sprites). Die letzten 4 Parameter sind die gleichen wie bei drawSprite.
screen.drawSpritePart("icon",4,4,8,8,0,50,50,50)
Die Höhe kann, wie im obigen Beispiel, weggelassen werden. In diesem Fall wird die Höhe entsprechend der Breite und den Proportionen des Sprite-Teils berechnet.
("map" = "Karte")
Zeichnet eine der Maps, die du im Abschnitt Maps erstellt hast. Der erste Parameter ist der Namen der anzuzeigenden Karte (ein String), z.B. "map1". Dann folgen die x,y-Koordinaten, wo die Karte angezeigt werden soll (die Karte wird auf diesen Koordinaten zentriert). Dann die Breite width und Höhe height, die die Karte auf dem Bildschirm haben soll.
screen.drawMap("map1", 0, 0, 300, 200)
Zeichnet Text auf den Bildschirm. Der erste Parameter ist der anzuzeigende Text (ein String), dann die x- und y-Koordinaten (Mittelpunkt des Textes), dann die Schriftgröße size des Textes. Der letzte Parameter ist die Farbe color, er kann weggelassen werden. In diesem Fall wird die zuletzt definierte Farbe wieder verwendet.
screen.drawText("Hallo!",0,0,30, "#FFF")
("set" = "setzen", "font" = "Schriftart")
Definiert die Schriftart, die bei Aufrufen von drawText verwendet werden soll.
Verfügbare Schriftarten in der aktuellen Version: AESystematic, Alkhemikal, AlphaBeta, Arpegius, Awesome, BitCell, Blocktopia, Comicoro, Commodore64, DigitalDisco, Edunline, EnchantedSword, EnterCommand, Euxoi, FixedBold, GenericMobileSystem, GrapeSoda, JupiterCrash, Kapel, KiwiSoda, Litebulb8bit, LycheeSoda, MisterPixel, ModernDos, NokiaCellPhone, PearSoda, PixAntiqua, PixChicago, PixelArial, PixelOperator, Pixellari, Pixolde, PlanetaryContact, PressStart2P, RainyHearts, RetroGaming, Revolute, Romulus, Scriptorium, Squarewave, Thixel, Unbalanced, UpheavalPro, VeniceClassic, ZXSpectrum, Zepto
screen.setFont("BitCell")
Tip: die globale Variable Fonts ist ein Array aller in microStudio verfügbaren Schriftarten.
Läd die Schriftart mit dem Namen font_name. (macht sie einsatzbereit)
Nutze screen.isFontReady bevor du sie verwendest. (siehe unten)
screen.loadFont("DigitalDisco")
Gibt 1 (wahr) zurück, wenn die Schriftart geladen und einsatzbereit ist. Stelle sicher, dass screen.loadFont vorher aufgerufen wird, ansonsten wird die Schriftart nie geladen.
Der Parameter font_name kann weggelassen werden. I diesem Fall wird geprüft, ob die aktuelle Schriftart geladen ist. (Die Standard Schriftart oder die Schriftart aus dem letzten Aufruf von screen.setFont( font_name )).
if screen.isFontReady() then
// die Standard-Schriftart wurde geladen
screen.drawText("Mein Text!",0,0,50)
end
// lade "DigitalDisco"
screen.loadFont("DigitalDisco")
// stelle s sicher, dass die Schriftart geladen ist, bevor sie genutzt wird
if screen.isFontReady("DigitalDisco")
screen.setFont("DigitalDisco")
screen.drawText("Mehr Text",0,50,20)
end
Gibt die Breite des Textes zurück, wenn er auf dem Bildschirm mit der angegebenen Schriftgröße size gezeichnet wird.
width = screen.textWidth( "Mein Text", 20 )
Definiert den Deckungsgrad "Alpha" für die folgenden Zeichenfunktionen. Der Wert 0 bedeutet völlige Transparenz (unsichtbare Elemente) und der Wert 1 entsprechend volle Deckkraft (die gezeichneten Elemente verdecken vollständig, was darunter liegt).
screen.setAlpha(0.5) // die nächsten gezeichneten Elemente werden halbtransparent sein
Achte darauf, den Alpha-Wert wieder auf den Standardwert 1 zu setzen nachdem du durchsichtige Elemente gezeichnet hast.
screen.setAlpha(1) // der Standardwert, volle Deckkraft
Definiert einen linearen Farbverlauf, d. h. einen Gradienten. x1 und y1 definieren den Startpunkt des Gradienten, x2 und y2 den Endpunkt. color1 ist die Farbe am Startpunkt und "color2" die Farbe am Endpunkt (siehe setColor für die Farbwerte).
screen.setLinearGradient(0,100,0,-100, "#FFF", "#F00")
screen.fillRect(0,0,screen.width,screen.height)
Das obige Beispiel erzeugt einen Farbverlauf von Weiß #FFF nach Rot #F00, vom oberen bis zum unteren Rand des Bildschirms und füllt dann den Bildschirm mit diesem Farbverlauf.
Definiert einen radialen Farbverlauf, d.h. einen kreisförmigen Verlauf. x und y sind die Koordinaten des Mittelpunktes des Kreises, radius ist der Kreisradius. color1 ist die Farbe im Kreismittelpunkt, color2 ist die Farbe am Rand des Kreises (siehe setColor für die Farbwerte).
screen.setRadialGradient(0,0,100, "#FFF", "#F00")
screen.fillRect(0,0,screen.width,screen.height)
Das obige Beispiel erzeugt einen Farbverlauf von Weiß in der Mitte des Bildschirms nach Rot an den Rändern des Bildschirms und füllt dann den Bildschirm mit diesem Farbverlauf.
Legt eine Verschiebung (Translation, Offset) der Bildschirmkoordinaten für die nachfolgenden Zeichenoperationen fest.
screen.setTranslation(50,50)
screen.fillRect(0,0,20,20)
Das Rechteck im obigen Beispiel wird mit einem Offset von 50,50 gezeichnet.
Achte darauf, den Offset wieder auf den Standardwert (0,0) zu setzen nachdem du die verschobenen Elemente gezeichnet hast.
screen.setTranslation(0,0)
Legt einen Rotationswinkel 'angle' für die nächsten Zeichenoperationen fest. Der Winkel wird in Grad angegeben.
screen.setDrawRotation(45)
screen.drawSprite ("icon",0,0,100)
Das obige Beispiel zeigt das Projektsymbol um 45 Grad gedreht an.
Achte darauf, den Drehwinkel danach wieder zurück auf 0 zu setzen.
screen.setDrawRotation(0) // setzt den Rotationswinkel auf den Standardwert 0 zurück
Definiert einen Skalierungsfaktor für das Zeichnen der nächsten Elemente. x definiert den Skalierungsfaktor auf der x-Achse und y den auf der y-Achse. Ein Wert von 2 bedeutet eine Verdoppelung der Größe. Ein Wert von -1 spiegelt ein Sprite horizontal (x) oder vertikal (y).
screen.setDrawScale(1,-1)
screen.drawSprite("icon",0,0,100)
Das obige Beispiel zeigt das Projektsymbol vertikal gespiegelt.
Achte darauf, den Skalierungsfaktor nach der Verwendung wieder auf (1,1) zu setzen.
screen.setDrawScale(1,1) // setzt den Skalierungsfaktor auf den Standardwert zurück.
("Anchor" = "Anker") Standardmäßig werden alle Formen auf den Ankerpunkt (x,y) zentriert gezeichnet, x und y beschreiben den Mittelpunkt der Form. Mit dieser Funktion kannst du einen anderen Ankerpunkt für das Zeichnen von Formen definieren.
In x-Richtung kann der Ankerpunkt auf -1 (linke Seite Ihrer Form), 0 (Mitte Ihrer Form), 1 (rechte Seite Ihrer Form) oder einen beliebigen Zwischenwert gesetzt werden. In y-Richtung kann der Ankerpunkt auf -1 (Unterseite Ihrer Form), 0 (Mitte Ihrer Form), 1 (Oberseite Ihrer Form) oder einen beliebigen Zwischenwert gesetzt werden.
Beispiele
screen.setDrawAnchor(-1,0) // nützlich, um Text linksbündig auszurichten
screen.setDrawAnchor(-1,-1) // die Zeichenkoordinaten werden jetzt als die linke untere Ecke Ihrer Form interpretiert.
screen.setDrawAnchor(0,0) // Standardwert, alle Formen werden zentriert auf die Koordinaten gezeichnet
Definiert den Compositing-Modus, also wie folgende Zeichenoperationen mit den schon gezeichneten Formen zusammengeführt oder überlagert werden.
Kann zB auf normal oder additive gesetzt werden.
Du kannst alle Compositing-Modi verwenden, die in der HTML5-Canvas-Spezifikation unter setBlending definiert sind.
Mehr Informationen unter: https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation
("width" = "Breite")
Das Attribut width des Objekts screen hat als Wert die aktuelle Bildschirmbreite (200 im Hochformat, siehe Bildschirmkoordinaten).
("height" = "Höhe")
Das Attribut height des Objekts screen hat als Wert die aktuelle Bildschirmhöhe (200 im Querformat, siehe Bildschirmkoordinaten).
("visible" = "sichtbar") Mit dieser Funktion kannst Du den Mauszeiger ein- oder ausblenden.
Um dein Programm interaktiv werden zu lassen, musst Du wissen, ob und wo der Benutzer eine Taste auf der Tastatur oder dem Joystick drückt oder den Touchscreen berührt. microStudio ermöglicht es dir, den Status dieser verschiedenen Eingabegeräte abzurufen. Und zwar über die Objekte keyboard (für die Tastatur), touch (für den Touchscreen / Maus), mouse (für Mauszeiger / Touchscreen) und gamepad (für den Controller).
Das Objekt system.inputs enthält nützliche Informationen, welche Eingabegeräte auf dem Hostsystem verfügbar sind:
| Attribut | Wert |
|---|---|
| system.inputs.keyboard | 1 wenn das System eine physische Tastatur hat, sonst 0 |
| system.inputs.mouse | 1 wenn das System eine Maus hat, 0 sonst |
| system.inputs.touch | 1 wenn das System einen Touchscreen hat, 0 sonst |
| system.inputs.gamepad | 1 wenn mindestens ein Gamepad an das System angeschlossen ist, 0 sonst (das Gamepad wird nur erkannt, wenn der Benutzer eine Aktion damit ausgeführt hat) |
Tastatureingaben können mit dem keyboard-Objekt abgefragt werden.
if keyboard.A then
// die Taste A wird gedrückt
end
Beachte beim Testen, dass du erst einmal in das Run-Fenster klicken musst, damit es die Tastaturereignisse erreichen.
Der folgende Code zeigt die ID jeder gedrückten Taste an. Das ist hilfreich, um die genauen Tastenbezeichnungen herauszufinden, die Du für dein Projekt brauchst.
draw = function()
screen.clear()
local y = 80
for key in keyboard
if keyboard[key] then
screen.drawText(key,0,y,15, "#FFF")
y -= 20
end
end
end
microStudio bietet auch einige nützliche generische Codes, wie UP, DOWN, LEFT und RIGHT, die je nach Tastaturlayout sowohl auf die Pfeiltasten als auch auf ZQSD / WASD reagieren.
Um Sonderzeichen wie +, - oder Klammern abzufragen, musst Du folgende Syntax verwenden: keyboard["("], keyboard["-"].
Innerhalb der Funktion update() kannst Du mit keyboard.press.<KEY> abfragen, ob eine Taste der Tastatur genau jetzt vom Benutzer gedrückt wurde.
Beispiel:
if keyboard.press.A then
// Einmalig etwas tun, wenn der Benutzer gerade die Taste A drückt
end
Innerhalb der Funktion update() kannst Du mit keyboard.release.<KEY> abfragen, ob eine Taste der Tastatur genau jetzt vom Benutzer losgelassen wurde.
Beispiel:
if keyboard.release.A then
// Einmalig etwas tun, wenn der Benutzer gerade die Taste A loslässt
end
Die Touch-Eingaben können mit dem touch-Objekt abgefragt werden (das auch den Status der Maus meldet).
| Attribut | Wert |
|---|---|
| touch.touching | 1, wenn der Benutzer den Touchscreen berührt, 0 wenn nicht |
| touch.x | x-Position, an der der Touchscreen berührt wird |
| touch.y | y-Position, an der der Touchscreen berührt wird |
| touch.touches | Falls Sie mehrere Berührungen gleichzeitig stattfinden, ist touch.touches eine Liste der aktuell aktiven Berührungspunkte |
| touch.press | 1, wenn eine Berührung genau jetzt begonnen hat |
| touch.release | 1, wenn eine Berührung genau jetzt beendet wurde |
if touch.touching
// der Benutzer berührt den Touchscreen
else
// der Benutzer berührt den Touchscreen nicht
end
draw = function()
for t in touch.touches
screen.drawSprite("icon",t.x,t.y,50)
end
end
Das obige Beispiel zeigt das Projektsymbol an jedem aktiven Berührungspunkt auf dem Bildschirm.
Die Mauseingaben können mit dem mouse-Objekt (das auch Touch-Events meldet) getestet werden.
| Attribut | Wert |
|---|---|
| mouse.x | x-Position des Mauszeigers |
| mouse.y | y-Position des Mauszeigers |
| mouse.pressed | 1, wenn eine beliebige Taste der Maus gedrückt ist, sonst 0 |
| mouse.left | 1, wenn linke Maustaste gedrückt ist, sonst 0 |
| mouse.right | 1, wenn rechte Maustaste gedrückt ist, sonst 0 |
| mouse.middle | 1, wenn mittlere Maustaste gedrückt ist, sonst 0 |
| mouse.press | 1, wenn genau jetzt eine Maustaste gedrückt wurde, sonst 0 |
| mouse.release | 1, wenn genau jetzt eine Maustaste losgelassen wurde, sonst 0 |
Mit dem "gamepad"-Objekt können die Tasten und Joysticks am Controller (Gamepad) abgefragt werden.
if gamepad.UP then y += 1 end
Tipp: Für eine vollständige Attributliste des gamepad-Objekts, gib einfach "gamepad" in die Konsole ein, wenn Dein Programm läuft.
Genauso wie für Tastendrücke kannst Du mit gamepad.press.<BUTTON> prüfen, ob eine Taste genau jetzt gedrückt oder mit gamepad.release.<BUTTON>, ob eine Taste genau jetzt losgelassen wurde.
microStudio wird bald einen eigenen Bereich zum Erstellen von Sounds und Musik haben. Bis es soweit ist, kannst du den Piepser zu verwenden, um Ihre Kreationen auf einfache Weise mit Sounds zu versehen.
microStudio currently allows you to play sounds and music you have imported to your project (as WAV files and MP3 files) or to create sounds programmatically using the legacy beeper.
Spielt den Sound, mit den optionalen Einstellungen ab.
| Parameter | Beschreibung |
|---|---|
| name | Name des Sounds der abgespielt werden soll (aus dem Sound-Tab in deinem Projekt) |
| volume | [optional] Die Lautstärke mit der der Sound abgespielt werden soll. Wertebereich von 0 bis 1 |
| pitch | [optional] Die Tonhöhe mit der der Sound abgespielt werden soll. 1 ist der Standardwert |
| pan | [optional] Die Position im Stereopanorama, an der der Sound abgespielt werden soll. -1 = Links, 1 = Rechts |
| loop | [optional] Setze loop auf 1 (true) um den Sound im Loop abzuspielen |
Der Funktionsaufruf gibt ein Objekt zurück. Mit diesem Objekt lassen sich die Wiedergabeparameter ändern, während der Sound wiedergegeben wird:
my_sound = audio.playSound("soundname")
my_sound.setVolume(0.5)
| Funktion | Beschreibung |
|---|---|
| my_sound.setVolume(volume) | Ändert die Lautstärke (Wertebereich von 0 bis 1) |
| my_sound.setPitch(pitch) | Ändert die Tonhöhe (Standardwert ist 1) |
| my_sound.setPan(pan) | Ändert die Panoramaposition (-1 = Links, 1 = Rechts) |
| my_sound.stop() | Stoppt die Wiedergabe |
Spielt eine Musikdatei, mit den optionalen Einstellungen ab.
| Patameter | Beschreibung |
|---|---|
| name | Name der Musikdatei die abgespielt werden soll (aus dem Sound-Tab in deinem Projekt) |
| volume | [optional] Die Lautstärke mit der die Musik abgespielt werden soll. Wertebereich von 0 bis 1 |
| loop | [optional] Setze loop auf 1 (true) um die Musik im Loop abzuspielen |
Der Funktionsaufruf gibt ein Objekt zurück. Mit diesem Objekt lassen sich die Wiedergabeparameter ändern, während die Musik wiedergegeben wird:
my_music = audio.playMusic("musicname")
my_music.setVolume(0.5)
| Funktion | Beschreibung |
|---|---|
| my_music.setVolume(volume) | Ändert die Lautstärke (Wertebereich von 0 bis 1) |
| my_music.stop() | Stoppt die Wiedergabe |
| my_music.play() | Nimmt die Wiedergabe wieder auf, wenn sie vorher gestoppt wurde |
| my_music.getPosition() | Gibt die aktuellen Wiedergabezeit/-position in Sekunden zurück |
| my_music.getDuration() | Gibt die Dauer der Musikdatei zurück |
Spielt einen Ton ab, der durch die als Parameter übergebene Zeichenkette (String) beschrieben wird.
audio.beep("C E G")
Ausführlicheres Beispiel und Erklärungen in der Tabelle unten:
"saw duration 100 span 50 duration 500 volume 50 span 50 loop 4 C2 C F G G G F end"
| Befehl | Beschreibung |
|---|---|
| saw | gibt den Typ des Klangerzeugers (Klangfarbe) an, mögliche Werte: saw, sine, square, noise |
| duration | gefolgt von einer Zahl, die die Dauer der Note in Millisekunden angibt |
| tempo | gefolgt von einer Zahl, die das Tempo in bpm (beats per minute) angibt |
| span | gefolgt von einer Zahl zwischen 1 und 100, die die Haltedauer der Note in Prozent angibt |
| volume | gefolgt von einer Zahl zwischen 0 und 100, stellt die Lautstärke ein |
| C | oder D, E, F usw. gibt eine zu spielende Note an. Es ist auch möglich, die Oktave anzugeben, z. B. C5 für das C der 5. Oktave der Klaviatur. |
| loop | , gefolgt von einer Zahl, die angibt, wie oft die folgende Sequenz wiederholt werden soll. Die Sequenz endet mit dem Schlüsselwort end Beispiel: Loop 4 C4 E G end; die Zahl 0 bedeutet, dass die Schleife unendlich oft wiederholt werden soll. |
Stoppt alle beeps die grad vom beeper gespielt werden. Das hilft um z.B. den Ton stumm zu schalten, nachdem eine Musikschleife gestartet wurde.
Dein Programm kann auf die Sprites deines Projekts zugreifen. Diese sind einem vordefinierten Objekt sprites gespeichert:
mysprite = sprites["icon"]
Du kannst dann auf verschiedene Attribute und Methoden deines Sprites zugreifen:
| Attribut/Methode | descBeschreibungription |
|---|---|
mysprite.width |
Breite des Sprites in Pixeln |
mysprite.height |
Höhe des Sprites in Pixeln |
mysprite.ready |
1 wenn das Sprite vollständig geladen ist, sonst 0 |
mysprite.name |
Name des Sprites |
Hinweis: Es können auch andere Attribute und native Methoden erscheinen, wenn Du ein Sprite-Objekt in der Konsole untersuchst. Solche undokumentierten Attribute und Methoden können in Zukunft verschwinden, verlasse Dich sich also nicht zu sehr auf sie!
Dein Programm kann auf die Maps (Karten) deines Projekts zugreifen. Diese sind einem vordefinierten Objekt Maps gespeichert:
mymap = maps["map1"]
Du kannst dann auf verschiedene Attribute und Methoden deiner Map zugreifen:
| Attribut/Methode | Beschreibung |
|---|---|
mymap.width |
Breite der Map in Zellen |
mymap.height |
Höhe der Map in Zellen |
mymap.block_width |
Breite der Map-Zelle in Pixel |
mymap.block_height |
Höhe der Map-Zelle in Pixel |
mymap.ready |
1 wenn die Map vollständig geladen ist, sonst 0 |
mymap.name |
Name der Map |
mymap.get(x,y) |
Gibt den Namen des Sprites in Zelle (x,y) zurück; Der Koordinatenursprung (0,0) ist unten links in der Map. Gibt 0 zurück, wenn die Zelle leer ist |
mymap.set(x,y,name) |
Setzt ein neues Sprite in Zelle (x,y); Der Koordinatenursprung (0,0) ist unten links in der Map. Der dritte Parameter ist der Name des Sprites. |
mymap.clone() |
Gibt eine neue Map zurück, die eine vollständige Kopie von mymap ist. |
Hinweis: Es können auch andere Attribute und native Methoden erscheinen, wenn Du ein Sprite-Objekt in der Konsole untersuchst. Solche undokumentierten Attribute und Methoden können in Zukunft verschwinden, verlasse Dich sich also nicht zu sehr auf sie!
(dt.: Medieninhalt) Der Assetmanager von microStudio ermöglicht es dir, verschiedene Dateitypen in dein Projekt zu integrieren und sie aus dem Code zu laden. Momentan werden folgende Asset-Formate unterstützt:
- .TTF: Schriftarten, die für Text benutzt werden können
- .JSON: JSON strukturierte Daten werden als microScript-Objekt geladen
- .GLB, .OBJ: 3D-Modelle (können nur mit Babylon.js oder micro3D geladen und verwendet werden)
- .TXT: einfache Textdateien, die als Zeichenkettenwert (String) geladen werde
- .CSV: Komma-getrennte Wertedateien (z.B. Tabellen), wird als String geladen
Den Assets Tab musst du für dein Projekt aktivieren. Klicke dafür im Menü auf das "+" ganz unten. Im Bereich "Active Tabs" aktiviere den Haken bei "Assets"
Im Gegensatz zu Sprites, Karten und anderen integrierten Assets werden die von dir importierten Assets nicht vorgeladen, wenn du dein microStudio-Projekt ausführst. Du musst sie aus deinem Code laden. Das Laden erfolgt asynchron. Es gibt zwei Möglichkeiten um zu prüfen, ob dein Asset geladen ist und verwendet werden kann:
- Du kannst eine optionale Callback-Funktion festlegen; die Funktion wird aufgerufen, wenn das Asset geladen wird, wobei die Daten als Parameter übergeben werden.
- Die Ladefunktion gibt auch ein
loader-Objekt zurück, das das Attribut.readyhat. Sobald.ready1 (true) zurückgibt, sind die Daten bereit und als Attribut imloader-Objekt enthalten.
Lässt ein Schriftart-Assets laden.
Nun kannst du prüfen, ob die Schrift bereit ist, und sie dann genau wie integrierte Schriften verwenden:
if screen.isFontReady("myfont") then ... end
screen.setFont("myfont")
Lässt ein JSON-Asset laden. Das Ergebnis ist ein microScript-Objekt, das alle Daten enthält.
Das Laden erfolgt asynchron. Du hast zwei Möglichkeiten um zu prüfen, ob es abgeschlossen ist:
asset_manager.loadJSON("somefolder/myjsonfile", function(data)
myobject = data
end)
loader = asset_manager.loadJSON("somefolder/myjsonfile")
(...)
if loader.ready then
myobject = loader.data
end
Lässt ein TEXT-Asset laden. Das Ergebnis ist ein microScript-String, das den Text enthält.
Das Laden erfolgt asynchron. Du hast zwei Möglichkeiten um zu prüfen, ob es abgeschlossen ist:
asset_manager.loadText("somefolder/mytextfile", function(text)
mytext = text
end)
loader = asset_manager.loadText("somefolder/mytextfile")
(...)
if loader.ready then
mytext = loader.text
end
Lässt ein CSV-Asset laden. Das Ergebnis ist ein microScript-String, das den Text der Datei enthält.
Info: CSV-Inhalte werden als reine Textdateien zurückgegeben. Um das Parsing (Analysieren und Zerlegen) musst du dich in deinem Code kümmern. Das Laden erfolgt asynchron. Du hast zwei Möglichkeiten um zu prüfen, ob es abgeschlossen ist:
asset_manager.loadCSV("somefolder/mycsvfile", function(text)
mytext = text
end)
loader = asset_manager.loadCSV("somefolder/mycsvfile")
(...)
if loader.ready then
mytext = loader.text
end
Lässt ein .md-Asset laden. Das Ergebnis ist ein microScript-String, das den Text der Datei enthält.
asset_manager.loadMarkdown("somefolder/mymdfile", function(text)
mytext = text
end)
loader = asset_manager.loadMarkdown("somefolder/mymdfile")
(...)
if loader.ready then
mytext = loader.text
end
Lässt ein 3D-Modell-Asset laden. Das funktioniert nur, wenn du in deinem Projekt "Babylon.js" oder "micro3D" als Grafikengine eingestellt hast. Das Ergebnis ist ein container-Objekt, das die Modelldaten enthält.
Das Laden erfolgt asynchron. Du hast zwei Möglichkeiten um zu prüfen, ob es abgeschlossen ist:
asset_manager.loadModel("somefolder/mymodelfile", function(container)
container.addAllToScene()
// or check Babylon.js documentation for other ways to handle the result
// asset_manager.loadModel is mapped on BABYLON.SceneLoader.LoadAssetContainer
end)
loader = asset_manager.loadModel("somefolder/mymodelfile")
(...)
if loader.ready then
loader.container.addAllToScene()
end
Das Objekt system liefert allgemeine Informationen über das Host-System, die aktuelle Zeit und gibt etwas Kontrolle über den Programmablauf.
Liefert Informationen über die Eingabegeräte deines Systems: Tastatur, Maus, Touchscreen oder Gamepad.
Wird auf die bevorzugte Sprache des Benutzers eingestellt.
Gibt die aktuelle effektive Bildrate an. (fps = "Frames per second", dt.: "Bilder pro Sekunde")
(dt.: Ansage)
Öffnet ein Pop-Up-Fenster in dem der Text message angezeigt wird.
Öffnet ein Pop-Up-Fenster, das den Benutzer auffordert, einen Text einzugeben.
Die übergebene Callback-Funktion wird mit zwei Parametern aufgerufen, callback( ok, text )
| Parameter | Beschreibung |
|---|---|
| ok | 1 wenn der Benutzer seine Eingabe bestätigt hat, sonst 0 |
| text | der vom Benutzer getippte Text, wenn er die Eingabe bestätigt hat |
Pausiert die Ausführung des Programms. Das funktioniert nur, wenn das Programm innerhalb der microStudio-Entwicklungsumgebung ausgeführt wird. Die Ausführung kann in microStudio manuell fortgesetzt werden. (Play-Button)
Beendet das Programm.
Gibt die verstrichene Zeit seit dem 1. Januar 1970 in Millisekunden zurück.
(dt.: Speicher)
Das Objekt storage ermöglicht die dauerhafte Speicherung Deiner Anwendungsdaten. Du kannst es nutzen, um Spielstände, Highscores oder andere Statusinformationen über dein Spiel oder Projekt zu speichern.
Speichert dauerhaft den Wert value, der durch die Zeichenkette (String) name referenziert wird. Der Wert kann eine beliebige Zahl, Zeichenkette (String), Liste oder ein strukturiertes Objekt sein.
Gibt den Wert zurück, der unter der Referenz name dauerhaft gespeichert ist. Gibt 0 zurück, wenn kein solcher Datensatz existiert.