The Block · Unity 6

APIs, tools & libraries - and the flow between them

ממשקי API, כלים וספריות - והזרימה ביניהם

An Israeli GTA-style 3D mini open world built in Unity 6 (URP) and shipped as a desktop app for macOS and Windows. Four diagrams: what the game calls while you play, the order the engine calls it in every frame, what the Editor does long before the game runs, and the AI toolchain that drives all of it.

עולם פתוח קטן בתלת-ממד, ישראלי ובסגנון GTA, שנבנה ב-Unity 6 (URP) ונארז כאפליקציית שולחן עבודה ל-macOS ול-Windows. ארבעה תרשימים מסבירים אותו: במה המשחק משתמש בזמן שמשחקים בו, באיזה סדר המנוע קורא לכל חלק בכל פריים, מה קורה בעורך הרבה לפני שהמשחק בכלל רץ, ומהי שרשרת כלי ה-AI שמניעה את כל אלה.

• 162 runtime scripts, 38,923 lines
• 54 Editor scripts, 20,602 lines
• 52 build menu items
• Unity 6000.5.8f1, URP

• 162 סקריפטים של זמן ריצה, 38,923 שורות
• 54 סקריפטים של העורך, 20,602 שורות
• 52 פריטי תפריט בנייה
• Unity 6000.5.8f1, URP

1 - Runtime

1 - זמן ריצה

What the app actually calls while you play

במה האפליקציה באמת משתמשת בזמן המשחק

The whole game is one desktop process - a .app bundle on macOS, a folder beside TheBlockUnity.exe on Windows. There is no server, no database, no login and no LLM at runtime - and no network at all: nothing is fetched while you play, because every mesh, texture, clip and scene is already inside the build. The game talks to Unity's own subsystems and to nothing else.

כל המשחק הוא תהליך שולחני יחיד - חבילת .app ב-macOS, ותיקייה שיושבת לצד TheBlockUnity.exe ב-Windows. אין שרת, אין בסיס נתונים, אין התחברות ואין מודל שפה בזמן ריצה - ולמעשה אין רשת בכלל: שום דבר לא נמשך מהאינטרנט בזמן המשחק, מפני שכל מודל, טקסטורה, קליפ אנימציה וסצנה כבר ארוזים בתוך הבילד עצמו. המשחק מדבר רק עם תת-המערכות של Unity, ועם שום דבר מעבר להן.

Most of what is installed is Editor-side; six subsystems do work while the game is running. The one API that reaches the disk is PlayerPrefs, and it holds eleven fixed keys plus three that expand per item. It is also the only line in the diagram whose destination is OS-specific: a plist under ~/Library/Preferences on macOS, a registry key under HKCU\Software on Windows. Unity decides that, not the game.

רוב מה שמותקן בפרויקט חי בצד העורך בלבד; רק שש תת-מערכות עושות עבודה בפועל בזמן שהמשחק רץ. ה-API היחיד שנוגע בדיסק הוא PlayerPrefs, והוא מחזיק אחד-עשר מפתחות קבועים ועוד שלושה שמתרבים לפי מספר הפריטים (מכונית שנצבעה, שדרוג שנקנה). זו גם השורה היחידה בתרשים שהיעד שלה משתנה בין מערכות הפעלה: קובץ plist תחת ~/Library/Preferences ב-macOS, ומפתח ברג׳יסטרי תחת HKCU\Software ב-Windows. Unity היא שקובעת את זה, לא קוד המשחק.

2 - Flow

2 - זרימה

Which API is called, and when

איזה API נקרא, ומתי

Phase A - boot, behind the loading bar

שלב א׳ - עלייה, מאחורי פס הטעינה

The game has two scenes: Boot.unity, which is a bar and nothing else, and World.unity, which is the entire city. BootLoader drives the handoff, and the four numbers below were measured on the Player, not guessed.

למשחק יש שתי סצנות בלבד: Boot.unity, שאינה אלא פס טעינה, ו-World.unity, שהיא כל העיר כולה. BootLoader אחראי על המעבר ביניהן, וארבעת המספרים שלמטה נמדדו על הבילד הסופי עצמו, לא נוחשו.

1. ~1.9 s - Unity's own startup: Metal or Direct3D, Mono, PhysX, subsystems. No script of mine has run yet.
2. SessionReset.Run() in Awake, before the load - a Quit to Title comes back through this scene with the previous world's registries still populated.
3. SceneManager.LoadSceneAsync("World") with allowSceneActivation = false. Unity stops a held load at progress == 0.9, which maps cleanly onto a bar that caps itself at 99 %. ~2.2 s, and it is one blocked frame: deserializing a 7.8 MB scene.
4. Activation - 245 ms for every Awake in the world at once - then the texture upload, ~1.9 s, and the first frame with real geometry.
5. GameFlow shows the title menu at Time.timeScale = 0. The title screen is not a scene: it is a UI Toolkit overlay on the loaded, frozen city, so it costs nothing to leave.

1. כ-1.9 שניות - העלייה של Unity עצמה: אתחול Metal או Direct3D, ‏Mono, ‏PhysX ושאר תת-המערכות. בשלב הזה אף שורת קוד שלי עוד לא רצה.
2. קריאה ל-SessionReset.Run() בתוך Awake, לפני תחילת הטעינה - מפני שיציאה מהמשחק חזרה לתפריט הראשי עוברת שוב דרך הסצנה הזו, כשהרישומים של העולם הקודם עדיין מלאים בנתונים ישנים.
3. קריאה ל-SceneManager.LoadSceneAsync("World") עם allowSceneActivation = false. ‏Unity עוצרת טעינה מוחזקת בדיוק ב-progress == 0.9, וזה מתמפה יפה לפס התקדמות שנעצר מעצמו על 99%. השלב אורך כ-2.2 שניות, והוא פריים חסום אחד ארוך: פענוח הסריאליזציה של סצנה במשקל 7.8 MB.
4. ההפעלה עצמה - 245 מילישניות שבהן כל קריאות ה-Awake בעולם רצות בבת אחת - ואחריה העלאת הטקסטורות לזיכרון הכרטיס, כ-1.9 שניות, ואז הפריים הראשון עם גאומטריה אמיתית על המסך.
5. ‏GameFlow מציג את התפריט הראשי בזמן ש-Time.timeScale = 0. מסך הפתיחה אינו סצנה נפרדת: הוא שכבת UI Toolkit שמצוירת מעל העיר הטעונה והקפואה, ולכן היציאה ממנו אל תוך המשחק אינה עולה זמן טעינה כלל.

Phase B - menu

שלב ב׳ - תפריט

Every panel in UI/Menus is dumb: it draws itself and raises a callback. GameFlow owns all the decisions - who is on screen, what Esc does, and when the clock starts. Continue reads PlayerPrefs and restores the unlocked mission; New Game clears it. Then timeScale goes to 1 and the loop below starts running for real.

כל פאנל בתיקייה UI/Menus הוא "טיפש" בכוונה: הוא רק מצייר את עצמו ומרים callback כשלוחצים עליו. GameFlow הוא זה שמחזיק את כל ההחלטות - מי מוצג על המסך, מה מקש Esc עושה בכל רגע, ומתי שעון המשחק מתחיל לרוץ. המשך משחק קורא את PlayerPrefs ומשחזר את המשימה האחרונה שנפתחה; משחק חדש מוחק אותם. משם timeScale עולה ל-1 והלולאה שמתוארת למטה מתחילה לרוץ באמת.

Phase C - every frame

שלב ג׳ - כל פריים ופריים

Three systems worth naming, because they are what the boxes above are mostly running: CampaignRunner is the campaign's single reactor - cursor, police rules, retry key, payout, HUD lines - and owns no gameplay of its own; a mission spawns its own actors and is only ever asked for a MissionStatus. CrimeWatch and Heat hold the wanted level, and PoliceSystem spawns cop cars that drive on PhysX wheels while the officer who gets out walks on a NavMeshAgent. TrafficSystem and CrowdSpawner keep the city populated around the player and recycle everything behind them.

שלוש מערכות ראויות לשם מפורש, מפני שהן מה שהתיבות שלמעלה מריצות רוב הזמן: CampaignRunner הוא הריאקטור היחיד של הקמפיין - הסמן על המפה, חוקי המשטרה, מקש הניסיון החוזר, התשלום בסוף המשימה ושורות ה-HUD - ואין לו גיימפליי משל עצמו; כל משימה יוצרת את השחקנים והאובייקטים שלה, ונשאלת רק על MissionStatus - האם היא רצה, הצליחה או נכשלה. CrimeWatch ו-Heat יחד מחזיקים את רמת המבוקשות, ו-PoliceSystem מייצר ניידות שנוסעות על גלגלי PhysX, בעוד שהשוטר שיוצא מהנידת הולך על NavMeshAgent. ‏TrafficSystem ו-CrowdSpawner דואגים שהעיר תהיה מאוכלסת סביב השחקן, וממחזרים כל מכונית והולך רגל שנשארו מאחוריו.

3 - Editor time

3 - זמן עורך

The pipeline that runs before the game ever does

הצינור שרץ עוד לפני שהמשחק בכלל מופעל

In a browser build, loading art is a runtime problem. In Unity it is an import problem, and that is where most of this project's tooling lives: 54 Editor scripts, 20,602 lines, exposing a 52-item The Block menu. Those builders are the reason the scene is reproducible - the city, the cars, the HUD, the missions and the police are all generated by a menu item from constants in TheBlockConfig, never dragged into place by hand.

בבילד לדפדפן, טעינת האמנות היא בעיה של זמן ריצה. ב-Unity זו בעיה של ייבוא, ושם יושב רוב הכלים שנכתבו לפרויקט הזה: 54 סקריפטים של העורך, ‏20,602 שורות, שחושפים תפריט The Block בן 52 פריטים. הבנאים האלה הם הסיבה שהסצנה ניתנת לשחזור מלא - העיר, המכוניות, ה-HUD, המשימות והמשטרה כולם נוצרים בלחיצה על פריט תפריט, מתוך קבועים שיושבים ב-TheBlockConfig, ואף אחד מהם לא נגרר למקומו ביד.

4 - Toolchain

4 - שרשרת הכלים

How the work gets done

איך העבודה עצמה נעשית

The course's subject is building with AI, so this is not a footnote: the Editor, Blender and the measurement runs are all driven from one Claude Code session over the Model Context Protocol. Two MCP servers are connected, and each is a real process on the machine rather than a cloud service - nothing here is a paid tier: no Unity Cloud, no Asset Store, no Unity AI credits.

נושא הקורס הוא בנייה בעזרת AI, ולכן זו לא הערת שוליים אלא חלק מהארכיטקטורה: העורך של Unity, ‏Blender והרצות המדידה מונעים כולם מתוך סשן אחד של Claude Code, דרך Model Context Protocol - פרוטוקול שמאפשר למודל להפעיל כלים חיצוניים. שני שרתי MCP מחוברים, וכל אחד מהם הוא תהליך אמיתי שרץ על המחשב עצמו ולא שירות ענן - שום דבר כאן אינו שירות בתשלום: לא Unity Cloud, לא Asset Store, ולא קרדיטים של Unity AI.

Inventory

מלאי

Every API, tool and library, and when it runs

כל API, כלי וספרייה - ומתי כל אחד מהם רץ

Runtime - inside the shipped app

זמן ריצה - בתוך האפליקציה הארוזה

Editor & toolchain - on my machine

העורך ושרשרת הכלים - על המחשב שלי

Content pipeline - offline, never shipped as code

צינור התוכן - עובד לא מקוון, ולעולם לא נשלח כקוד