שפת BASIC

בשורה אחת#

aukimi משנעת ניב BASIC קלאסי: שפה מלאה, לא מערכת מאקרו צעצועית, עם מספרים בעלי טיפוס, רשומות, מתודות, הפניות, שגיאות מובנות, קורוטינות וחישוב WebGPU. היא חיה במצב התצוגה TXT של Engine ובתצוגת BASIC של עורך הסקריפטים.

JavaScript נשארת ה-API הקאנוני לכתיבת סקריפטים. BASIC היא frontend אופציונלי: שניהם מתקמפלים לאותו dispatcher פרטי, כך שתוכנית BASIC ותוכנית JavaScript מגיעות לאותו מנוע בדיוק. שום דבר לא מדרגה שנייה, ושום דבר לא runtime נפרד.

החוק שתופס את כולם#

קריאה לפקודה תמיד נושאת סוגריים.

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

זה לא עניין של סגנון. זה מה שמאפשר למהדר להבדיל פקודה ממשתנה, וזו הסיבה ששגיאת כתיב נתפסת עכשיו בזמן קומפילציה:

טעות כתיבה נהגה להציג את עצמה כבאג של המנוע. נמדד מול קורפוס ההדגמות בן 84 היחידות, השומר הפיק אפס תוצאות שווא ומצא שני כשלים שקטים אמיתיים, SetMusicSystemVolume ו-GetLightSensorExists, שהקטלוג מכיר רק כ-MusicSystemVolume וכ-LightSensorExists.

שני חורים נשארים פתוחים בכוונה: console.log("x") ו-window.x = 1 עדיין עוברים. שומר לזה נכתב, נמדד, ובוטל: BASIC רץ בתוך הקשר שמספק שמות שהמהדר לא יכול למנות, אז דחיית שורש לא ידוע דחתה תוכניות תקינות. תוצאה שווא שם גרועה יותר מהחור.

Print מצייר. Console רושם.#

ההפתעה הנפוצה ביותר:

Print בתוך לולאת פריים היה מטביע כל שגיאה אמיתית ביומן, וזו הסיבה ששתי הפקודות נפרדות במקום אחת עם דגל.

טיפוסים#

טיפוסים מספריים הם אמיתיים, ומתנהגים זהה בכל יעד, העורך, ייצוא ה-HTML, ובניית ה-Bevy/native:

• מספרים שלמים חתומים ולא-חתומים בני 8, 16, 32 ו-64 סיביות, עם קואורדינציה דטרמיניסטית, DIV שלם, וגלישת (wrapping) גלישה.
• float32 ו-float64.
• הסיגלים הקלאסיים עדיין עובדים: name$ הוא מחרוזת, speed# מספר עשרוני.

OPTION EXPLICIT הוא בבחירה (opt-in), ומשתנים משתמעים קלאסיים נשארים ברירת המחדל כך שתוכניות מיובאות עדיין רצות. הפעלתו היא התנאי לשני התכונות שלא יכולות להיות בטוחות בלעדיה, טיפוס מספרי והפניות, כי השמה עם שגיאת כתיב שיוצרת משתנה בשקט מבטלת את שניהם.

מבנים#

רשומות#

TYPE מכריז רשומה. הן מקוננות באופן שרירותי, ויש להן סמנטיקת ערך: השמת אחת מעתיקה אותה לעומק, כולל מערכים ואוספים מקוננים.

מתודות#

METHOD קושר פונקציה למופע, עם SELF בתוכה, New לבנייה ו-Delete להריסה. עותקים עמוקים נשארים בטוחים למתודות.

הפניות#

REF ו-BYREF הם אותו הדבר תחת שני שמות, ושניהם נותנים פרמטר חי לקריאה/כתיבה, עבור סקלר, רשומה, שדה בודד, מערך, מצביע רשימה או ערך במפה. הפניות ממשיכות דרך קריאות, וקואורדינטות לטיפוסים ברוחב קבוע בגבול.

handles#

@target לוקח הפניה ממדרגה ראשונה. HANDLE ו-POINTER הם הצורות המוקלדות, עם קריאה, כתיבה, תקפות ושחרור נבדקים, ו-handle לרשומה שנמחקה מבוטל במקום להישאר תלוי.

בקרה ובטיחות#

שגיאות מובנות: TRY / CATCH / FINALLY, מקוננים, עם THROW, RETHROW מוגן, ולכידה גם מובנית וגם כמחרוזת.

קומפילציה מותנית: #IF / #ELSEIF / #ELSE / #ENDIF, מקוננים, עם דגלי תכונה ופרופילים מפורשים לעורך, HTML, Bevy, native/wasm ו-debug/release. זה נפתר לפני includes, בכל יעד.

פונקציות עשירות: ערכי ברירת מחדל, OPTIONAL, PARAMARRAY אחרון (או ...), עומסי-יתר בטוחים, קואורדינציית ערך חוזר מוקלדת, והחזרות רשומה ומערך משוכפלות.

תוכניות מרובות-קבצים#

#INCLUDE, #INSERT ו-IncludeFile הופכות תוכנית לכמה קבצים. העורך יוצר ומייבא מודולי פרויקט, משלים נתיבי include, שומר את גרף התלויות, וכל יעד runtime מחווט לזה.

קורוטינות, והדבר שהושמט בכוונה#

משימות שיתופיות מבוססות תווית, עם handles מוקלדים, מצב תוצאה ושגיאה, ביטול בנקודות yield, וawait על משימה אחת או קבוצה. הן חולקות את מתזמן המשחק בכל יעד.

תהליכונים עם זיכרון משותף מושמטים בכוונה. לא "עדיין לא", מושמטים. מתזמן שיתופי שאפשר לנמק לגביו עדיף על race condition שאי אפשר לשחזר.

חישוב WebGPU#

מאגרי אחסון מוקלדים f32 / i32 / u32, pipelines גולמיים ב-WGSL, dispatch מסודר-פריים וקריאה חוזרת של memblock, חישוב GPU אמיתי מ-BASIC.

⚠️ Engine בלבד. יעד ה-HTML מעלה שגיאת יכולת מפורשת, ויעד ה-Bevy מדווח על אי-ההתאמה לפני הבנייה במקום להפיק בינארי שנכשל בשליחה הראשונה.

שני קיצורי דרך לאותה בעיה#

597 מהפקודות נקראות Set/Get<Object><Property>: Sprite 66, Tween 58, Text 32, Edit 29. שם האובייקט נמצא בתוך שם הפונקציה וה-id שלו הוא הארגומנט הראשון של כל שורה. שני קיצורי הדרך למטה מסירים את החזרתיות הזו, ואף אחד מהם אינו API חדש: המהדר בונה מחדש את שם הפקודה האמיתי ומחפש אותו בקטלוג.

WITH <family>, בתוך בלוק#

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

בראש הוראה \prop כותב; בכל מקום אחר הוא קורא. המיקום קובע, אז אין סימון שני ללמוד. WITH hero, טוקן אחד, עדיין בלוק הרשומה; WITH SPRITE s בוחר משפחת קטלוג.

s.position(...), בכל מקום אחר#

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)

המשפחה מגיעה מ-Create<F> / Load<F> / Clone<F>, או מ-s AS Sprite מפורש כשה-id מגיע ממקום אחר. רק משתנים שהמשפחה שלהם ידועה נכתבים מחדש: רשומות שומרות את השדות שלהן, רשימות שומרות את המתודות שלהן, SELF.field נשאר ללא נגיעה.

⚠️ פרמטר מוקלד לא מזוהה. FUNCTION move(s AS Sprite) לא נותן ל-s משפחה, המעבר קורא רק הכרזות והשמות ברמת ההוראה. נכתב כאן כי זו מגבלה אמיתית, לא באג שצריך לצוד.

⚠️ הקטלוג מוריד את הפועל בתכונות, ושומר אותו במחזור חיים. SpritePosition כותב, SpriteX קורא, ואף אחד מהם לא נושא Set או Get: 4 פקודות בכל הקטלוג מתחילות ב-Set, ואף אחת לא מתחילה ב-Get. הפועל שורד היכן שמשהו נוצר או מסתיים: CreateSprite, LoadImage, DeleteSprite.

זה שווה לדעת כי שגיאת כתיב היא שגיאת קומפילציה, ו-Set… היא שגיאת הכתיב שאנשים מגיעים איתה. הקטלוג הוא הסמכות, ו-הרפרנס נוצר ממנו.

אינטרפולציית מחרוזות, בבחירה#

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

{{ ו-}} כותבים סוגריים מסולסלים מילוליים.

⚠️ הקידומת $ היא חובה, והיא לא קישוט. אינטרפולציה של כל מחרוזת שברה JSON כתוב ביד, ש-API העולם לוקח באופן שגרתי:

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

שם הסוגריים המסולסלים הם נתונים, לא חורים. מחרוזת ללא קידומת נשארת ללא נגיעה בכל תוכן שהיא נושאת.

מתן שם הוא הצגה#

תוכנית קלאסית יוצרת מאות אובייקטים. רק אלה שהיא נותנת להם שם נכנסים ל-Scene Graph, SpriteName(id, "player") ואחיה הם מה שמכניס אובייקט לעץ שבו שאר Engine יכול לראות אותו. LightName ו-ParticlesName עושים אותו הדבר לאור ופולט.

המדריך תנו שם למה שהתוכנית שלכם יוצרת עובר על זה: אותה סצנה, פעם אחת עם עץ ריק ופעם אחת עם שלוש רשומות בו.

קטלוג הפקודות#

2,237 פקודות, 2,550 עומסי-יתר ציבוריים, 43 קטגוריות. הגדולות ביותר:

בתוספת 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 ו-Compute הן התוספות של aukimi לניב הקלאסי, פקודות הקונסולה, מתן שם לאובייקטים, וה-pipeline של WebGPU.

רפרנס הפקודות המלא מפרט את כולן, עם כל פרמטר וכל עומס-יתר, וחיפוש משלו, נוצר מאותו קטלוג שהעמוד הזה סופר, כך שהוא לא יכול לפגר אחריו. גם פאנל ה-API של העורך קורא את הקטלוג הזה.

העמוד הזה מתעד את השפה; העמוד ההוא מתעד את הפקודות.

מגבלות ותקלות נפוצות#

• סוגריים אינם אופציונליים בפקודה. הצורה החשופה של PureBasic (Debug "x") נדחית, כי היא פותחת מחדש את הדו-משמעות משתנה/פקודה שהשומר בזמן הקומפילציה תלוי בה.
• פונקציה של משתמש מנצחת פקודה מקוטלגת באותו שם, ומשתנה יכול לחלוק שם עם פקודה בהכרזה מוקלדת, בצד שמאל של השמה, או כשורש של path.
• משתנים ופונקציות משתמש אינם תלויי-רישיות, ומרחבי הסימן שלהם נפרדים לגמרי מהקטלוג.
• Print הוא לא יומן. ראו למעלה; זו הטעות שממלאת קונסולה.
• Compute לא מייצא. כתבו את מסלול הנפילה חזרה לפני שאתם נסמכים עליו.