BASIC-språket

I korthet#

Aukimi levererar en klassisk BASIC-dialekt: ett fullständigt språk, inte ett leksaksmakrosystem, med typad numerik, poster, metoder, referenser, strukturerade fel, korutiner och WebGPU-beräkning. Den lever i Engines TXT-vyläge och i skripteditorns BASIC-vy.

JavaScript förblir det kanoniska skript-API:et. BASIC är en valfri frontend: båda kompileras till samma privata dispatcher, så att ett BASIC- program och ett JavaScript-program når exakt samma motor. Inget är andra klassens, och inget är en separat runtime.

Regeln som fångar alla#

Ett kommandoanrop bär alltid parenteser.

mode = ClipSpaceMode()
SpritePosition(player, 320, 180)

Det här är inte stil. Det är vad som låter kompilatorn skilja ett kommando från en variabel, och det är varför en felstavning nu fångas vid kompilering:

Ett skrivfel framstod tidigare som en motor-bugg. Mätt mot korpusen med 84 demon producerade skyddet noll falska positiva och hittade två riktiga tysta fel, SetMusicSystemVolume och GetLightSensorExists, som katalogen bara känner som MusicSystemVolume och LightSensorExists.

Två läckor lämnas öppna med flit: console.log("x") och window.x = 1 går fortfarande igenom. Ett skydd för dem skrevs, mättes och drogs tillbaka: BASIC körs inuti ett sammanhang som tillhandahåller namn kompilatorn inte kan räkna upp, så att neka en okänd rot avvisade giltiga program. En falsk positiv där är värre än läckan.

Print ritar. Console loggar.#

Den enskilt vanligaste överraskningen:

Print i en bildruteloop skulle dränka varje riktigt fel i konsolen, vilket är varför de två är separata kommandon i stället för ett med en flagga.

Typer#

Numeriska typer är verkliga, och de beter sig identiskt på varje mål, editorn, HTML-exporten och Bevy/native-bygget:

• Signerade och osignerade 8-, 16-, 32- och 64-bitars heltal, med deterministisk tvingning, heltals-DIV, och wrapping-overflow.
• float32 och float64.
• De klassiska sigillen fungerar fortfarande: name$ är en sträng, speed# en float.

OPTION EXPLICIT är valbart, och klassiska implicita variabler förblir standard så att importerade program fortfarande körs. Att slå på det är förutsättningen för de två funktioner som inte kan vara säkra utan det, numerisk typning och referenser, eftersom en felstavad tilldelning som tyst skapar en variabel omintetgör båda.

Strukturer#

Poster (records)#

TYPE deklarerar en post. De kan nästlas hur som helst, och de har värdesemantik: att tilldela en djupkopierar den, inklusive nästlade arrayer och samlingar.

Metoder#

METHOD binder en funktion till en instans, med SELF inuti den, New för att konstruera och Delete för att förstöra. Djupkopior förblir metodsäkra.

Referenser#

REF och BYREF är samma sak under två stavningar, och båda ger en levande läs/skriv-parameter, för en skalär, en post, ett enskilt fält, en array, en listmarkör eller en mappnyckel. Referenser förs vidare genom anrop, och tvingas till fastbreddstyper vid gränsen.

Handtag#

@target tar en förstaklassens referens. HANDLE och POINTER är de typade formerna, med kontrollerad läsning, skrivning, giltighet och frisläppning, och ett handtag till en raderad post ogiltigförklaras i stället för att lämnas hängande.

Kontroll och säkerhet#

Strukturerade fel: TRY / CATCH / FINALLY, nästlat, med THROW, skyddad RETHROW, och både strukturerade och strängbaserade catchar.

Villkorlig kompilering: #IF / #ELSEIF / #ELSE / #ENDIF, nästlat, med funktionsflaggor och explicita profiler för editorn, HTML, Bevy, native/wasm och debug/release. Den löses innan includes, på varje mål.

Rika funktioner: standardvärden, OPTIONAL, en avslutande PARAMARRAY (eller ...), säkra aritetsöverlagringar, typad returtvingning, och klonade post- och array-returer.

Program med flera filer#

#INCLUDE, #INSERT och IncludeFile gör ett program till flera filer. Editorn skapar och importerar projektmoduler, kompletterar include-sökvägar, håller beroendegrafen, och varje runtime-mål är kopplat för det.

Korutiner, och det som medvetet uteslöts#

Kooperativa uppgifter är etikettbaserade, med typade handtag, ett resultat- och feltillstånd, avbrytning vid yields, och awaits på en uppgift eller en grupp. De delar spelets schemaläggare på varje mål.

Trådar med delat minne är medvetet uteslutna. Inte "inte än", uteslutna. En kooperativ schemaläggare du kan resonera kring slår ett datarace du inte kan återskapa.

WebGPU-beräkning#

Typade f32 / i32 / u32-lagringsbuffertar, råa WGSL-pipelines, bildruteordnad dispatch och memblock-återläsning, riktig GPU-beräkning från BASIC.

⚠️ Bara Engine. HTML-målet ger ett explicit kapacitetsfel, och Bevy-målet rapporterar inkompatibiliteten innan bygget i stället för att producera en binär som misslyckas vid första dispatchen.

Två stenografier för samma problem#

597 av kommandona heter Set/Get<Objekt><Egenskap>: Sprite 66, Tween 58, Text 32, Edit 29. Objektets namn finns inuti funktionsnamnet och dess id är det första argumentet i varje rad. Båda stenografierna nedan tar bort den repetitionen, och ingen av dem är ett nytt API: kompilatorn bygger om det riktiga kommandonamnet och slår upp det i katalogen.

WITH <familj>, inuti ett block#

WITH SPRITE s
  \position 100, 200      ` SpritePosition(s, 100, 200)
  \size 64, 64            ` SpriteSize(s, 64, 64)
  x# = \x                 ` SpriteX(s)
ENDWITH

I huvudet av en sats skriver \prop; var som helst annars läser den. Position avgör, så det finns ingen andra notation att lära sig. WITH hero, ett enda token, är fortfarande postblocket; WITH SPRITE s väljer en katalogfamilj.

s.position(...), överallt annars#

s = CreateSprite(img)     ` the family is DEDUCED from the creation command
s.position(100, 200)      ` SpritePosition(s, 100, 200)
s.visible = 1             ` SpriteVisible(s, 1)
x# = s.x                  ` SpriteX(s)

Familjen kommer från Create<F> / Load<F> / Clone<F>, eller från en explicit s AS Sprite när id:t kommer någon annanstans ifrån. Bara variabler vars familj är känd skrivs om: poster behåller sina fält, listor behåller sina metoder, SELF.field rörs inte.

⚠️ En typad parameter känns inte igen. FUNCTION move(s AS Sprite) ger inte s en familj, passet läser bara deklarationer och tilldelningar på satsnivå. Sagt här eftersom det är en riktig begränsning, inte en bugg du ska leta efter.

⚠️ Katalogen tappar verbet på egenskaper, och behåller det på livscykel. SpritePosition skriver, SpriteX läser, och ingen av dem bär ett Set eller Get: 4 kommandon i hela katalogen börjar med Set, och inget börjar med Get. Verbet överlever där något kommer till eller upphör: CreateSprite, LoadImage, DeleteSprite.

Det är värt att veta eftersom en felstavning är ett kompileringsfel, och Set… är felstavningen folk kommer med. Katalogen är auktoriteten, och referensen genereras från den.

Strängar med interpolering, valbart#

Print($"score: {points}")        ` "score: " + Str(points)

{{ och }} skriver bokstavliga klammerparenteser.

⚠️ Prefixet $ är obligatoriskt, och det är ingen dekoration. Att interpolera varje bokstavlig sträng bröt handskriven JSON, som world-API:et använder rutinmässigt:

CreateTerrain("island", "{\"preset\":\"island\",\"size\":256}")

Där är klamrarna data, inte hål. En sträng utan prefix lämnas orörd oavsett vad den innehåller.

Att namnge är att visa#

Ett klassiskt program skapar hundratals objekt. Bara de som NAMNGES kommer in i Scene Graph, SpriteName(id, "player") och dess syskon är vad som sätter ett objekt i trädet där resten av Engine kan se det. LightName och ParticlesName gör detsamma för ett ljus och en emitter.

Handledningen Namnge det ditt program skapar går igenom det, samma scen, en gång med trädet tomt och en gång med tre poster i det.

Kommandokatalogen#

2 237 kommandon, 2 550 publika överlagringar, 43 kategorier. De största:

plus JSON (36), Image (35), Skeleton (34), XML (34), Music (29), Preference (27), Extras (21), HTTP (21), String (21), Math (19), Regular Expression (19), Video (18), Dictionary (17), Benchmarking (15), Compute (14), Date (13), Maths (12), Time (12), StringBuilder (9), Compression (7), Font (8), Error (4), Array (3), Cipher (2), Sort (2).

Studio och Compute är Aukimis egna tillägg till den klassiska dialekten, konsolkommandona, objektnamngivningen, och WebGPU-pipelinen.

Den fullständiga kommandoreferensen listar alla av dem, med varje parameter och varje överlagring, och sin egen sökning, genererad från samma katalog den här sidan räknar, så att den inte kan komma på efterkälken. Editorns egen API-panel läser också den katalogen.

Den här sidan dokumenterar språket; den andra dokumenterar kommandona.

Begränsningar och vanliga fallgropar#

• Parenteser är inte valfria på ett kommando. Den nakna PureBasic-formen (Debug "x") avvisas, eftersom den återöppnar den variabel/kommando- tvetydighet som kompileringstidsskyddet bygger på.
• En användarfunktion vinner över ett katalogiserat kommando med samma namn, och en variabel kan dela namn med ett kommando i en typad deklaration, till vänster om en tilldelning, eller som roten i en sökväg.
• Variabler och användarfunktioner är skiftlägesokänsliga, och deras symbolrymder är genuint separata från katalogens.
• Print är ingen logg. Se ovan; det är misstaget som fyller en konsol.
• Compute exporterar inte. Skriv reservvägen innan du förlitar dig på den.