Issuu on Google+

‫שנקר ‪ -‬בי"ס גבוה להנדסה ולעיצוב‬ ‫הפקולטה להנדסה‬ ‫המחלקה להנדסת תוכנה‬

‫‪SimuLAWtor Editor‬‬ ‫פרויקט גמר‬ ‫מאת‬ ‫יגר בן‪-‬טל‬ ‫מנחה‪ :‬ד'ר ישע סיון‬ ‫מוגש כחלק מהדרישות לקבלת תואר ראשון‬ ‫בוגר במדעים (‪.)B.Sc.‬‬

‫‪15.10.2010‬‬

‫‪1‬‬


‫תוכן‬ ‫תקציר ‪3 ..................................... ................................ ................................ ................................‬‬ ‫טבלאות ואיורים ‪4 ........................ ................................ ................................ ................................‬‬ ‫מילון מונחים ‪5 ............................. ................................ ................................ ................................‬‬ ‫מטרות ‪6 .................................... ................................ ................................ ................................‬‬ ‫מסמך אפיון ‪7 .............................. ................................ ................................ ................................‬‬ ‫מסמך תיכון ‪10 ............................ ................................ ................................ ................................‬‬ ‫מבוא ‪14 .................................... ................................ ................................ ................................‬‬ ‫מקורות ‪15 ................................. ................................ ................................ ................................‬‬ ‫רקע על סביבת העבודה ‪16 ............ ................................ ................................ ................................‬‬ ‫היישום ‪18 .................................. ................................ ................................ ................................‬‬ ‫בדיקות‪ ,‬תוצאות והערכה ‪22 .......................................... ................................ ................................‬‬ ‫מסקנות ופיתוחים עתידיים ‪23 ........................................ ................................ ................................‬‬

‫‪2‬‬


‫תקציר‬ ‫ה‪ SimuLAWtor Editor-‬הינו ממשק בניית מסלולי נהיגה תלת ממדיים בסביבה וירטואלית‪,‬‬ ‫המשלבים בתוכם אלמנטים לפיקוח על ציות לחוקי התנועה‪ .‬ה‪ SimuLAWtor Editor -‬פונה הן‬ ‫לאנשים שאיבדו את כושר הנהיגה ולמטפליהם‪ ,‬והן למשתמשים העומדים בפני הוצאת רישיון נהיגה‬ ‫ורוצים לרכוש מיומנות זו בטרם עלייתם על הכביש‪.‬‬ ‫הממשק בנוי משני חלקים‪ .‬הראשון‪ ,‬הינו הרכיב הבונה את המסלולים‪ ,‬הנמצא בסביבת ‪Second‬‬ ‫‪ ,Life‬שהיא פלטפורמה המפעילה עולם תלת ממדי וירטואלי‪ .‬השני‪ ,‬הוא אפליקציה הרצה בסביבת‬ ‫‪ JAVA‬ומקשרת בין פעולות המשתמש לבין אותו רכיב ב‪.Second Life -‬‬ ‫התכונות המרכזיות של הממשק הן יצירה‪ ,‬שמירה וטעינה של המסלולים הנ"ל‪ .‬פעולות אלו מבוצעות‬ ‫ע"י מעבר של הודעות בין אפליקציית ה‪ JAVA -‬לרכיב המקשר ב‪ .Second Life-‬לאחר יצירת מסלול‬ ‫המערכת בודקת אם המסלול חוקי‪ .‬במידה וכן‪ ,‬ניתנת למשתמש אפשרות לשמור אותו לקובץ בינארי‪.‬‬ ‫המשתמש יכול לחילופין גם לטעון מסלול מקובץ קיים‪ ,‬ולעורכו כרצונו‪.‬‬ ‫יצירת המסלול נעשית ע"י פריסת לוח עם משבצות ריקות תחילה‪ ,‬כשעל כל משבצת יש כפתורי‬ ‫עריכה‪ ,‬באמצעותם המשתמש בוחר את סוג חלק הדרך וכיוונו‪ .‬התקשורת בין האובייקטים בסביבת‬ ‫ה‪ Second Life-‬מבוססת על עקרון של העברת הודעות מאחד לשני‪.‬‬ ‫אפליקציית ה‪ JAVA-‬מכילה אובייקט מרכזי המייצג את המסלול‪ ,‬ומכיל מערך של אובייקטים‬ ‫המייצגים כל אחד משבצת במסלול‪ .‬אובייקט זה מושך את המידע על המסלול מסביבת ‪Second‬‬ ‫‪ ,Life‬ושומר אצלו את כל פרטיו‪.‬‬ ‫בבדיקות שנעשו בתום העבודה על הפרויקט‪ ,‬כל התכונות הקיימות נמצאו תקינות‪ .‬עם זאת‪ ,‬קיים‬ ‫מקום רב לשיפור והרחבתו של הפרויקט ; כמו למשל להעבירו לסביבת פיתוח אחרת‪ ,‬שהרי סביבת‬ ‫ה‪ Second Life-‬לא מתאימה לפרויקטים בסדר גודל כזה‪ ,‬אלא לפרויקטים יותר מינורים‪ .‬דבר זה גם‬ ‫יגרום לאיחוד שני חלקי הפרויקט‪ ,‬ויעלה את רמתו האינטואיטיבית‪.‬‬ ‫במהלך העבודה על הפרויקט‪ ,‬הוסקו מספר מסקנות לגבי סביבת ‪ .Second Life‬הראשונה היא‬ ‫שסביבה זו היא לא סגורה לגמרי‪ ,‬ושאפשר לפתח לה כלי עזר שישלטו עליה מבחוץ‪ .‬עם זאת‪,‬‬ ‫המסקנה השנייה היא שהסביבה לא מתאימה לפיתוח מערכות בסדר גודל כזה‪ ,‬אלא לפיתוח‬ ‫אפליקציות יותר קטנות‪ ,‬שלא מצריכות ביצוע של אלגוריתמים מורכבים‪ .‬דוגמא טובה לזה היא‬ ‫החוסר במבנה נתונים מסוג מערך‪ ,‬שהוא כלי בסיסי להרבה טכניקות בפיתוח‪.‬‬

‫‪3‬‬


‫טבלאות ואיורים‬ ‫איור ‪ - 1‬התוצר הסופי של התוכנה ‪6 ................................ ................................ ................................‬‬ ‫איור ‪ - 2‬אפליקצית ‪18 ...................................... ................................ ................................ SLClient‬‬ ‫איור ‪ - 3‬מצב בניית המסלול ‪18 ....................................... ................................ ................................‬‬ ‫איור ‪ - 4‬מציאת חלק לא חוקי במהלך בדיקת חוקיות המסלול ‪19 ........................... ................................‬‬ ‫איור ‪ - 5‬לאחר שהמסלול נמצא חוקי‪ ,‬נעלמיםכפתורי העריכה ומופיעה המכונית‪ .‬אפשר להתחיל לנהוג ‪19 .....‬‬ ‫איור ‪ Class Diagram - 6‬של אובייקט המערכת ב‪20 ....................................... ................................ SL-‬‬ ‫איור ‪21 ................................ ................................ ................................ SLClient UML Diagram - 7‬‬

‫‪4‬‬


‫מילון מונחים‬ ‫‪ – simuLAWtor Editor‬שם המדף של המוצר‪.‬‬ ‫‪ – SLClient‬אפליקציית ה‪ JAVA-‬המתקשרת עם אובייקט המערכת בסביבת ה‪ ,Second Life -‬ומנהלת‬ ‫את השמירה‪ ,‬הטעינה והעריכה של המסלולים‪.‬‬ ‫‪ – )SL( Second Life‬פלטפורמה וירטואלית תלת ממדית‪ ,‬מבוססת אינטרנט‪ ,‬שבתוכה מפותח המוצר‪.‬‬ ‫‪ – Viewer‬תוכנת התצוגה והעריכה של ‪.Second Life‬‬ ‫אווטאר – כינוי לדמות המשתמש בסביבת ה‪.SL -‬‬ ‫‪ - (LSL) Linden Script Language‬שפת התכנות איתה משתמשים בסביבת ה‪.SL -‬‬ ‫‪ – Prim‬כך נקראת אבן יסוד לבנייה בעולם ה‪ .Secon Life -‬חלק זה יכול להיות מחובר לחלקים‬ ‫אחרים‪ ,‬ולהכיל קטע קוד אותו הוא יבצע כל עוד הקוד מופעל‪.‬‬ ‫‪ – Texture‬כל אובייקט יכול ללבוש ‪ Texture‬שונה‪ ,‬שבמקור הוא תמונה‪ .‬קיימת אפשרות להעלות‬ ‫תמונות באמצעות ה‪ Viewer-‬ולשמור אותן כ‪.Textures-‬‬ ‫‪ – LIST‬מבנה נתונים בסביבת ה‪ ,Second Life-‬המזכיר מערך משולב עם מחסנית‪ .‬אפשר לקרוא‬ ‫ממנו את האיברים‪ ,‬אך לא ניתן לבצע בו השמה חוץ מלהוסיף איבר בסופו‪.‬‬ ‫‪ – State‬מצב‪ .‬מבנה השפה הוא של מצבים‪ .‬האובייקט יכול לעבור ממצב אחד למצב שני‪ ,‬כשבכל‬ ‫מצב מוגדר לו לעשות משהו אחר‪.‬‬

‫‪5‬‬


‫מטרות‬ ‫בעולם בכלל ובארץ בפרט יש עודף תאונות דרכים‪ .‬הרבה מהן נגרמות מחוסר תשומת ליבו של הנהג‬ ‫לרמזורים ותמרורים‪ .‬המטרה היא לבנות תוכנה שתאפשר למשתמשים בה לבנות בעצמם מסלול‬ ‫נהיגה כרצונם‪ ,‬תוך כדי הוספת תמרורים‪/‬רמזורים במקומות המתאימים לכך‪ .‬בכך הם יוצרים סביבת‬ ‫נהיגה וירטואלית‪ ,‬שמאמנת אותם למצב האמיתי בכביש‪ ,‬ומחדדת את תשומת ליבם לסימני הדרך‪.‬‬ ‫התוכנה פונה לקהל רחב של אנשים‪ .‬הן לאנשים שאיבדו את כושר הנהיגה כתוצאה ממחלה או בעיה‬ ‫רפואית‪ ,‬ונוסעים במסלולים אלו כדי לשפר את מיומנויות הנהיגה שלהם‪ ,‬והן למטפלים באותם‬ ‫אנשים‪ ,‬שבונים להם את מסלולי הנהיגה לפי הצורך האישי של כל מטופל‪ .‬בנוסף‪ ,‬תוכנה זו פונה גם‬ ‫לאנשים שעומדים בפני הוצאת רישיון נהיגה‪ ,‬ולכל נער וילד הרוצים להתנסות בנהיגה בכביש עוד‬ ‫טרם הגיעם לגיל המתאים להוצאת רישיון נהיגה‪.‬‬ ‫התוכנה כוללת ממשק בנייה של סימולטור נהיגה שישלב בתוכו מתן דגש לציות לחוקי התנועה‪.‬‬ ‫למשתמש יש אפשרות לשמור מסלול קיים‪ ,‬וכן לטעון מסלולים שמורים לכשירצה‪ ,‬ולעורכם‪.‬‬ ‫סימולטור הנהיגה כולל את חוקי התנועה הבאים‪ :‬עצירה בתמרור עצור‪ ,‬איסור על פניה שמאלה‪,‬‬ ‫מעבר בצומת מרומזר אור ירוק‪ ,‬ומתן זכות קדימה להולכי רגל במעבר חצייה‪.‬‬ ‫בנוסף‪ ,‬יש רכיב שסופר את הנקודות אותן צבר המשתמש ומציג לו אותן כשהוא מסיים את המסלול‪.‬‬

‫איור ‪ - 1‬התוצר הסופי של התוכנה‬

‫‪6‬‬


‫מסמך אפיון‬ ‫תאריך הגשת הדו"ח‬

‫‪8.3.10‬‬

‫שם הסטודנט‪/‬ים‬

‫יגר בן‪-‬טל‬

‫ת‪.‬ז‪ .‬סטודנט‪/‬ים‬

‫‪040610214‬‬

‫שם המנחה‬

‫דר' ישע סיון‬

‫שם הפרויקט‬

‫ממשק בניית סימולטור נהיגה‬

‫מטרות הפרויקט ואפיונו‬

‫בעולם בכלל ובארץ בפרט יש עודף תאונות דרכים‪.‬‬ ‫הרבה מהן נגרמות מחוסר תשומת ליבו של הנהג‬ ‫לרמזורים ותמרורים‪ .‬באמצעות הסימולטור‪ ,‬יכולים‬ ‫המשתמשים לבנות בעצמם את המסלול כרצונם‪ ,‬תוך‬ ‫כדי הוספת תמרורים‪/‬רמזורים במקומות המתאימים‬ ‫לכך‪ .‬בכך הם יוצרים סביבת נהיגה וירטואלית‪ ,‬המאמנת‬ ‫אותם למצב האמיתי בכביש‪ ,‬ומחדדת את תשומת ליבם‬ ‫לסימני הדרך‪.‬‬ ‫הסימולטור פונה לקהל רכב של אנשים‪ .‬אם זה אנשים‬ ‫שעומדים בפני הוצאת רשיון נהיגה‪ ,‬או אנשים שאיבדו‬ ‫את כושר הנהיגה כתוצאה ממחלה או בעיה רפואית‪.‬‬ ‫במקרה זה‪ ,‬הסימולטור פונה גם לאלו המטפלים באותם‬ ‫אנשים‪.‬‬ ‫הפרוייקט יכלול ממשק בנייה של סימולטור נהיגה‬ ‫המשלב בתוכו מתן דגש על ציות לחוקי התנועה‪.‬‬ ‫למשתמש תהיה אפשרות לשמור מסלול קיים וכן‪ ,‬לטעון‬ ‫מסלולים שמורים לכשירצה‪.‬‬ ‫סימולטור הנהיגה יכלול את חוקי התנועה הבאים‪:‬‬ ‫עצירה בתמרור עצור‪ ,‬איסור על פניה שמאלה‪ ,‬מעבר‬ ‫באור ירוק‪ ,‬עצירה לפני מעבר חציה במידה והוא לא‬ ‫פנוי‪.‬‬ ‫בנוסף‪ ,‬יהיה רכיב שיספור את הנקודות אותן צבר‬ ‫המשתמש‪.‬‬ ‫באם הזמן יאפשר‪ ,‬תתווסף לסימולטור אפשרות של‬ ‫ריבוי משתמשים‪ .‬הכוונה לנסיעה של שני משתמשים‬ ‫ויותר באותו מסלול בו זמנית‪ ,‬וכתוצאה מכך גם ניסעה‬ ‫של רכב במסלול הנגדי‪.‬‬ ‫בסך הכל‪ ,‬מכיוון שכבר בהצעת הפרויקט הראשונית‬ ‫‪7‬‬


‫הכיוון היה מאוד ברור‪ ,‬לא קיימים שינויים באפיון‬ ‫הפרויקט ומטרותיו‪.‬‬ ‫סקירת ספרות‬

‫שני אתרים המרכזים את כל המידע על כל הפקודות‬ ‫הקיימות בשפת ה‪:LSL-‬‬ ‫‪http://lslwiki.net‬‬ ‫‪http://wiki.secondlife.com/wiki/LSL_Portal‬‬

‫ביצוע הפרויקט‬

‫תכנון הפרויקט יתבצע באמצעות דיאגרמת מחלקות‪,‬‬ ‫שתתאר את האובייקטים המצויים בו ואת תפקידיהם‪.‬‬ ‫מימוש הפרויקט יהיה בשפת ה‪ ,LSL -‬שהיא שפת‬ ‫התכנות איתה משתמשת פלטפורמת ה‪.Second Life -‬‬ ‫כתיבת הקוד תלווה בעזרה מאתרי אינטרנט המרכזים‬ ‫את כל המידע בנוגע לשפת ‪( LSL‬ראה סעיף סקירת‬ ‫ספרות)‪.‬‬ ‫התכנות יתבצע בסביבת הפיתוח הנמצאת בתוך תוכנת‬ ‫ה‪.Second Life-‬‬

‫תוצרי הפרויקט‬

‫מערכת תוכנה בסביבת ‪.SECOND LIFE‬‬ ‫שלושה מסלולים המייצגים שלוש דוגמאות‪.‬‬ ‫במידה והזמן יאפשר – ננסה לעבוד עם לקוחות‬ ‫אמיתיים‪.‬‬

‫תוכנית עבודה‬

‫‪.1‬‬ ‫‪.2‬‬ ‫‪.3‬‬ ‫‪.4‬‬ ‫‪.5‬‬ ‫‪.6‬‬ ‫‪.7‬‬

‫בחירת חוקי התנועה שייושמו בסימולטור‪.‬‬ ‫שדרוג התמרורים הקיימים והתאמתם לפרויקט‬ ‫הגמר‪.‬‬ ‫חשיבה ותכנון האלגוריתמים לפיצוח הפרויקט‪.‬‬ ‫התחלת כתיבת הקוד‪.‬‬ ‫הכנת המצגת והכרזה‪.‬‬ ‫"פינישים" אחרונים בקוד של הפרוייקט‪.‬‬ ‫הגשת הפרוייקט‪.‬‬

‫דו"ח התקדמות ‪1‬‬ ‫השלב בו נמצא הפרויקט (‪%‬העבודה‬ ‫שבוצעה‪ ,‬נושאים מרכזיים לביצוע‬ ‫ונושאים מרכזיים שבוצעו)‪.‬‬

‫הפרויקט נמצא בשלב ההתחלתי שלו‪.‬‬ ‫עד עכשיו בוצעו כ‪ 10%-‬מהעבודה‪ ,‬שהם‪ :‬התאמת‬ ‫התמרורים הקיימים לממשק שייבנה‪ ,‬יצירת תמרור‬ ‫חדש (אין פניה שמאלה) וחשיבה על האלגוריתמים‬ ‫לפיהם יעבוד ממשק הבנייה (הפרויקט)‪.‬‬ ‫השלב הבא הוא לשרטט (טיוטה על דף נייר‪ ,‬ולאחר מכן‬ ‫קובץ ‪ )ppt‬שרטוט המתאר את מבנה הממשק‪,‬‬ ‫האובייקטים ממנו הוא בנוי‪ ,‬ואופן העבודה שלהם אחד‬ ‫‪8‬‬


‫עם השני (מי אחראי על מה‪ ,‬ומי שולט על מי)‪.‬‬ ‫בעיות‪/‬קשיים שהתגלו ונפתר ו‪ ,‬סטיות‬ ‫ושינויים מההצעה המקורית ומדו"ח‬ ‫ההתקדמות הקודם‪.‬‬

‫בעיה ראשונה שהייתה היא שהפרויקט הצריך מקום רב‬ ‫בתוך פלטפורמת ה‪ .Second Life-‬בעיה זו נפתרה ע"י‬ ‫הקצאת שטח גדול ע"י מנחה הפרויקט באי החדש של‬ ‫שנקר‪.‬‬ ‫בעיה נוספת שנמצאה היא התאמת התמרורים הקיימים‬ ‫לממשק החדש‪ .‬מכיוון שמערכת ה‪ Second Life-‬עובדת‬ ‫לפי קואורדינאטות ( ‪ ,)x,y,z‬כל ההתייחסות למיקום‬ ‫נעשתה ע"י הגדרת ערכים ספציפיים ביחס למיקום‬ ‫האובייקט‪ .‬בשל כך‪ ,‬ברגע שמסובבים את האובייקט‪,‬‬ ‫כיווניו משתנים‪ ,‬וצריך להחליף בין ערכי ה‪ x -‬לערכי ה‪.y-‬‬ ‫בעיה זו נפתרה ע"י מציאת אלגוריתם שונה‪ ,‬יותר‬ ‫מתוחכם‪ ,‬שידע לפי המיקום הנוכחי של האובייקט‪,‬‬ ‫להתאים לו את הקוד המתאים (ע"י שימוש במשפטי ‪.)if‬‬

‫בעיות שהתגלו וטרם נפתרו או‬ ‫שטרם הוחל הטיפול בהן (יש לציין‬ ‫את הסטאטוס ואת משמעות‬ ‫הבעיות; האם נדרשת עזרה?)‬

‫מכיוון שתכנון אלגוריתמי הפרויקט נמצא כרגע רק על‬ ‫הנייר‪ ,‬עדיין לא נמצא בעיה מהותית‪ .‬אולם‪ ,‬אין ספק‬ ‫שברגע שתתחיל כתיבת הקוד‪ ,‬ימצאו לא מעט בעיות‪,‬‬ ‫משום שסביבת הפיתוח של פלטפורמת ה‪Second Life -‬‬ ‫היא מאוד מוגבלת‪ .‬הרבה פקודות שמוכרות כמובנות‬ ‫מאליהן מסביבות פיתוח אחרות‪ ,‬לא תמיד כאלה‬ ‫פשוטות בעולם ה‪.Second Life-‬‬ ‫לדוגמא‪ :‬שימוש במערכים בסביבות הרגילות לעומת‬ ‫שימוש ב‪ List-‬בסביבת ה‪.Second Life-‬‬

‫תחזית לבעיות אפשריות נוספות‬ ‫ומשמעויותיהן על ביצוע הפרויקט‬

‫כאמור‪ ,‬צפויות בעיות במימוש האלגוריתמים‪ .‬משמעות‬ ‫בעיות אלו היא עיכוב בביצוע הפרויקט‪ .‬עם זאת‪ ,‬עם כל‬ ‫הקושי שיהיה‪ ,‬ומניסיון העבר‪ ,‬לא הייתה בעיה שבאמת‬ ‫לא הייתה אפשרית לפתרון‪.‬‬

‫תחזית עמידה בלו"ז‬

‫עד עכשיו עמדתי בלוח הזמנים‪ ,‬ולהערכתי אמשיך‬ ‫לעמוד בו‪.‬‬

‫‪9‬‬


‫מסמך תיכון‬ ‫תאריך הגשת הדו"ח‬ ‫שם הסטודנט‪/‬ים‬

‫יגר בן‪-‬טל‬

‫ת‪.‬ז‪ .‬סטודנט‪/‬ים‬

‫‪40610214‬‬

‫שם המנחה‬

‫ד'ר ישע סיון‬

‫שם הפרויקט‬

‫ממשק בניית סימולטור נהיגה‬

‫תקציר מטרות‬ ‫הפרויקט‬

‫הפרוייקט יכלול ממשק בנייה של סימולטור נהיגה המשלב בתוכו מתן‬ ‫דגש על ציות לחוקי התנועה‪ .‬למשתמש תהיה אפשרות לשמור מסלול‬ ‫קיים וכן‪ ,‬לטעון מסלולים שמורים לכשירצה‪.‬‬ ‫סימולטור הנהיגה יכלול את חוקי התנועה הבאים‪ :‬עצירה בתמרור‬ ‫עצור‪ ,‬איסור על פניה שמאלה‪ ,‬מעבר באור ירוק‪ ,‬עצירה לפני מעבר‬ ‫חציה במידה והוא לא פנוי‪.‬‬ ‫בנוסף‪ ,‬יהיה רכיב שיספור את הנקודות אותן צבר המשתמש‪.‬‬ ‫באם הזמן יאפשר‪ ,‬תתווסף לסימולטור אפשרות של ריבוי משתמשים‪.‬‬ ‫הכוונה לנסיעה של שני משתמשים ויותר באותו מסלול בו זמנית‪,‬‬ ‫וכתוצאה מכך גם ניסעה של רכב במסלול הנגדי‪.‬‬

‫תיכון הפרויקט‬ ‫הפתרונות שהוצעו‬ ‫והפתרון שנבחר‬

‫ראשית‪ ,‬נזכיר את סדר הפעולות של המשתמש‪ ,‬באופן כללי‪ ,‬ללא קשר‬ ‫לתוכנה הספציפית שנבנית כרגע במסגרת הפרוייקט‪:‬‬ ‫‪ .1‬בניית מסלול‪.‬‬ ‫‪ .2‬שמירת המסלול‪.‬‬ ‫‪ .3‬בדיקה ע"י המערכת אם המסלול חוקי (הכוונה שאין כבישים‬ ‫שנקטעים באמצע)‪.‬‬ ‫‪ .4‬שמירת המסלול לקובץ ע"י המערכת‪.‬‬ ‫‪ .5‬לבסוף‪ ,‬טעינת המסלול חזרה מתוך הקובץ‪.‬‬ ‫בראשית העבודה‪ ,‬היה צפוי שכל התוכנה תבנה בסביבת ה‪,SL -‬‬ ‫ותיכתב בשפת ‪ .LSL‬תוך כדי תכנות בתוך הסביבה הנ"ל‪ ,‬ניכר חוסר‬ ‫או מורכבות יתרה במנגנונים בסיסיים‪ .‬לדוגמא‪:‬‬ ‫‪‬‬

‫מערך‪ ,‬שהוא מבנה נתונים בסיסי שכמעט ואין תוכנה שעובדת‬ ‫בלעדיו‪ ,‬לא קיים בשפת ‪ .LSL‬במקום‪ ,‬קיים מבנה נתונים‬ ‫הנקרא "‪ "LIST‬שהוא הרבה יותר מוגבל‪ .‬מכיוון שהוא מכיל כל‬ ‫סוג אפשרי של טיפוסים ( ‪ ,)String, Integer, Vector etc.‬לא‬ ‫ניתן לבצע השמה באיבריו‪ .‬זאת משום שכל טיפוס תופס כמות‬ ‫שונה של זיכרון‪ .‬מה שכן אפשרי‪ ,‬זה להוסיף איבר לסוף ה‪-‬‬ ‫‪ LIST‬ולבצע משיכה של איברים‪ .‬זה לא מספיק‪.‬‬ ‫‪10‬‬


‫‪ ‬דוגמא שנייה‪ ,‬היא אופן התקשורת בין האובייקטים השונים של‬ ‫התוכנה‪ ,‬המתבצעת ע"י שליחת הודעות ( ‪ )Strings‬בערוצים‬ ‫שונים‪ ,‬ומצריכה מהאובייקט המקבל את ההודעה להיות תמיד‬ ‫בהאזנה לאותו ערוץ ספציפי‪.‬‬ ‫‪ ‬דוגמא שלישית‪ ,‬והכי משמעותית‪ ,‬היא שב‪ LSL -‬אין שום‬ ‫אפשרות לכתוב לתוך קובץ‪ ,‬שזוהי בעצם מהות התוכנה‪.‬‬ ‫הפתרון שנמצא לכך‪ ,‬הוא היעזרות בטכנולוגיה נוספת‪ ,JAVA ,‬לצורך‬ ‫ביצוע הפעולות המורכבות יותר‪ .‬כך‪ ,‬הפעולות ה"פיזיות" כמו בניית‬ ‫המסלול ועריכתו‪ ,‬נעשות בסביבת ‪ .SL‬ביצוע השמירה לקובץ‪ ,‬בדיקת‬ ‫חוקיות המסלול וטעינת הקובץ מחדש‪ ,‬יתבצעו באמצעות ‪.JAVA‬‬ ‫תאור רכיבי המערכת‬ ‫וארגונם‬

‫המערכת בנויה מהרכיבים הבאים‪:‬‬ ‫אובייקט מערכת‪ ,‬האחראי על יצירת הלוח ההתחלתי עליו ייבנה‬ ‫המסלול‪ ,‬ועל יצירת תקשורת חיצונית עם ה‪.Client -‬‬ ‫‪ Client‬חיצוני הבנוי בשפת ‪ ,JAVA‬ואחראי על שמירה‪ ,‬טעינה‪ ,‬ובדיקת‬ ‫חוקיות של מסלולים‪.‬‬ ‫ברזולוציה יותר גבוהה‪ ,‬בנוגע לבניית המסלול עצמו‪:‬‬ ‫אובייקט המערכת יוצר בהתחלה משטח של ריבועים‪ ,‬שעל כל אחד‬ ‫מהם יש שלושה כפתורים‪ ,Left ,Right :‬ו‪ Right .Rotation-‬ו‪Left-‬‬ ‫מעבירים בין הריבועים האפשריים (כביש ישר‪ ,‬פנייה שמאלה‪/‬ימינה‪,‬‬ ‫צומת וכו')‪ .‬ה‪ ,Rotation-‬תפקידו לשנות את כיוון הריבוע ע"י סיבובו ב‪-‬‬ ‫‪ 90‬מעלות עם כל לחיצה‪.‬‬

‫תאור מבני הנתונים‬

‫המסלול שנבנה ע"י המשתמש נשמר בשני ‪-LIST‬ים בסביבת ‪.SL‬‬ ‫‪ LIST‬אחד שומר את שמות הריבועים‪ ,‬והשני שומר את כיווניהם‬ ‫בהתאמה (‪ .)N,W,S,E‬לדוגמא‪ ,‬במצב שהריבוע השלישי בלוח מכיל‬ ‫ריבוע סיבוב שכיוונו הוא מערב‪ ,‬יתקיים‪:‬‬ ‫"‪Squares[2]="Curve‬‬ ‫"‪Directions[2]="W‬‬

‫ברגע שהמשתמש ירצה לשמור את המסלול‪ ,‬הוא ילחץ על כפתור ה‪-‬‬ ‫‪ Save‬ב‪ Client-‬החיצוני‪ ,‬ואז תתבצע משיכה החוצה‪ ,‬לסביבת ‪,JAVA‬‬ ‫של שני ‪-LIST‬ים אלו אל תוך אובייקט מסוג ‪ ,Track‬המכיל מידע על‬ ‫גודל המסלול (מספר הריבועים לאורך ולרוחב) ומערך של אובייקטים‬ ‫מסוג ‪ Square‬שכל אחד מהם מכיל את שמו של הריבוע‪ ,‬כיוונו‪ ,‬ועוד‬ ‫מידע שיעזור בבדיקת חוקיות המסלול‪.‬‬ ‫האלגוריתמים‬ ‫שיופעלו‬

‫אלגוריתם שמירת המסלול – לולאה שתופעל מה‪ ,Client-‬שתבצע כל‬ ‫פעם את הפעולות הבאות‪:‬‬ ‫‪‬‬ ‫‪‬‬

‫שליחת הודעה לרכיב ה‪ System-‬ב‪ SL-‬לקבלת פרטי הריבוע‬ ‫ה‪.i-‬‬ ‫שליחת הודעה מרכיב ה‪ System-‬לאותו ריבוע לקבלת שמו‬ ‫‪11‬‬


‫וכיוונו‪.‬‬ ‫‪ ‬החזרת הודעה מרכיב ה‪ System-‬אל ה‪ Client -‬החיצוני עם‬ ‫פרטי הריבוע ה‪.i-‬‬ ‫‪ ‬כתיבת הריבוע לתוך המערך של ה‪ Squares-‬באובייקט ה‪-‬‬ ‫‪.Track‬‬ ‫אלגוריתם בדיקת חוקיות המסלול‪ ,‬שיופעל מיד בתום האלגורית‪ ,‬לפני‬ ‫כתיבת המסלול לתוך קובץ‪:‬‬ ‫‪ ‬כל ריבוע מכיל מידע לגבי כל צדדיו (‪ ,)N,W,S,E‬אם קיים‬ ‫באותו צד כביש שמצריך המשך בריבוע שאחריו‪.‬‬ ‫‪ ‬האלגוריתם יבדוק לכל ריבוע בלוח‪ ,‬אם בריבוע שבא אחריו‬ ‫מצד שמאל‪ ,‬ואחריו למטה‪ ,‬יש גם כביש שמתחבר אליו‪.‬‬ ‫‪ ‬במידה ותמצא טעות באחד מהריבועים‪ ,‬תוצג על כך הודעה‬ ‫למשתמש מה‪ Client-‬החיצוני‪ ,‬ומספרו יישלח אל רכיב ה‪-‬‬ ‫‪ System‬ב‪ ,SL-‬וזה ידליק את אותו ריבוע בצבע אדום‪ ,‬המראה‬ ‫למשתמש באיזה ריבוע קיימת הבעיה‪.‬‬ ‫אלגוריתם טעינת המסלול – לולאה שתופעל מה‪ ,Client-‬שתבצע את‬ ‫הפעולות הבאות‪:‬‬

‫מבנה הממשק‬ ‫המתוכנן‬

‫‪ ‬שליחת הודעה לרכיב ה‪ System-‬ב‪ SL-‬לכתיבת פרטי הריבוע‬ ‫ה‪ i-‬בשני ה‪-LIST-‬ים המחזיקים את פרטי המסלול‪.‬‬ ‫‪ ‬שימוש במנגנון הבניה ההתחלתי של הלוח‪ ,‬רק שהפעם עם‬ ‫הפרטים של שם כל ריבוע וכיוונו (שניים מהפרמטרים ביצירת‬ ‫אובייקט חדש ב‪ SL-‬הם שם האובייקט וכיוונו)‪.‬‬ ‫הממשק יכלול שני חלקים‪:‬‬ ‫אפליקציית ‪ JAVA‬קטנה‪ ,‬שהיא בעצם חלון עם שני כפתורים‪ "Load" :‬ו‪-‬‬ ‫"‪."Save‬‬ ‫רכיב ‪ System‬בסביבת ‪ SL‬שצורתו עדיין לא נקבעה‪ .‬לחיצה עליו‬ ‫תשאל את המשתמש לגבי גודל המסלול הרצוי‪ ,‬ולפי זה הוא יצור לוח‬ ‫ריק חדש‪ ,‬המוכן לעריכה‪.‬‬ ‫בנוסף‪ ,‬יהיה עליו הסבר לגבי אופן השימוש בתוכנה‪.‬‬ ‫כנראה שיהיה קובץ ‪ Batch‬שיפעיל את שני הרכיבים הנ"ל‪.‬‬

‫מפרטי הבדיקה‬

‫בתהליך הבדיקה יבדקו ה‪ Scenarios -‬הבאים‪:‬‬ ‫‪‬‬ ‫‪‬‬ ‫‪‬‬

‫יצירת מסלול חדש‪ ,‬ושמירתו לקובץ‪.‬‬ ‫יצירת מסלול עם סוגים שונים של טעויות‪ ,‬ושמירתו לקובץ‪.‬‬ ‫טעינת קובץ מסלול קיים‪.‬‬

‫דו"ח התקדמות ‪2‬‬ ‫השלב בו נמצא‬ ‫הפרויקט (‪%‬העבודה‬ ‫שבוצעה‪ ,‬נושאים‬ ‫מרכזיים לביצוע‬ ‫ונושאים מרכזיים‬

‫‪50%‬‬ ‫עד עכשיו‪ ,‬מה שקיים זה אובייקט ‪ System‬ב‪ SL-‬שיוצר לוח שאותו‬ ‫אפשר לערוך לאיזה מסלול שרוצים‪ .‬כעת יש רק שלושה סוגים של‬ ‫ריבועים‪ ,‬אך ברגע שכל התוכנה תעבוד כמו שצריך‪ ,‬יתווספו הריבועים‬

‫‪12‬‬


‫שבוצעו)‪.‬‬

‫הנוספים‪.‬‬ ‫כמו כן‪ ,‬קיים ‪ Client‬חיצוני‪ ,‬עם המחלקות שהוזכרו קודם ( ‪ Track‬ו‪-‬‬ ‫‪ .)Square‬הוא יודע לשלוח הודעה (‪ )String/Int‬לרכיב ה‪ System-‬ב‪SL-‬‬ ‫ולקבל תשובה )‪ (String/Int‬חזרה‪.‬‬ ‫נושאים מרכזיים לביצוע ‪:‬‬

‫פונקציה לשמירת המסלול לקובץ‪.‬‬ ‫פונקציה לבדיקת חוקיות המסלול‪.‬‬ ‫פונקציה לטעינת מסלול מקובץ‪.‬‬ ‫הוספת כל שאר הריבועים הנוספים (שכבר קיימים) אל ה‪ System -‬ב‪-‬‬ ‫‪.SL‬‬ ‫בעיות‪/‬קשיים שהתגלו‬ ‫ונפתרו‪ ,‬סטיות‬ ‫ושינויים מההצעה‬ ‫המקורית ומדו"ח‬ ‫ההתקדמות הקודם‪.‬‬

‫כמו שנכתב הסעיף הראשון‪ ,‬היה צפוי שכל התכנות יתבצע ב‪LSL -‬‬ ‫בסביבת ‪ ,SL‬אך כתוצאה מהקשיים שפורטו שם‪ ,‬הוחלט להיעזר‬ ‫בשפת ‪ JAVA‬לצורך ביצוע פעולות מורכבות יותר‪ ,‬וכתיבה וטעינה של‬

‫קבצים‪.‬‬

‫בעיות שהתגלו וטרם‬ ‫נפתרו או ��טרם הוחל‬ ‫הטיפול בהן (יש לציין‬ ‫את הסטאטוס ואת‬ ‫משמעות הבעיות;‬ ‫האם נדרשת עזרה?)‬

‫לא קיימות כעת בעיות שאין להן פתרון‪.‬‬

‫תחזית לבעיות‬ ‫אפשריות נוספות‬ ‫ומשמעויותיהן על‬ ‫ביצוע הפרויקט‬

‫צפויה בעיה שמקורה באי התאמה בין רמת הביצועים של סביבת ‪SL‬‬ ‫המבוססת רשת‪ ,‬לזו של ה‪ Client -‬החיצוני‪ ,‬שעובד לוקאלית‪.‬‬

‫תחזית עמידה בלו"ז‬

‫פתרון לבעיה זו יינתן מראש ע"י שימוש בדגל בתוך כל לולאה (של‬ ‫שמירה או טעינה של קבצים) המצביע על החזרת תשובה מרכיב ה‪-‬‬ ‫‪ System‬ב‪ .SL-‬כך‪ ,‬ה‪ Client-‬החיצוני ישלח את ההודעה הבאה לרכיב‬ ‫ה‪ System-‬ב‪ ,SL-‬רק לאחר שקיבל ממנו תשובה‪ .‬פעולה זו אולי תגרום‬ ‫לביצועים יותר איטיים של התוכנה‪ ,‬אך תבטיח שלא יאבד מידע בדרך‪.‬‬ ‫אין בעיה עם עמידה בלוח הזמנים לעת עתה‪.‬‬

‫‪13‬‬


‫מבוא‬ ‫הפרויקט‪ ,‬או בשמו‪ SimuLAWtor Editor :‬הינו פרויקט המשך לפרויקט ה‪ ,SimuLAWtor-‬שנבנה‬ ‫בקורס יישומי מציאות מדומה בשנה ג'‪ .‬אותו פרויקט מכיל מסלול נהיגה וירטואלי‪ ,‬הבוחן את תשומת‬ ‫ליבו של המשתמש לחוקי תנועה שונים (צומת מרומזר‪ ,‬תמרור עצור‪ ,‬מעבר חצייה)‪ ,‬מציג לו הודעה‬ ‫ברגע שטעה‪ ,‬וסוכם את כמות טעויותיו‪ .‬ה‪ SimuLAWtor -‬נבנה בסביבת ה‪.Second Life-‬‬ ‫בעוד שה‪ SimuLAWtor-‬מכיל מסלול נהיגה אחד קבוע‪ ,‬ה‪ SimuLAWtor Editor-‬מכיל ממשק לבניית‬ ‫מסלולים‪ ,‬בו המשתמש יכול ליצור אין סוף מסלולים כאוות נפשו‪ .‬לאחר בניית המסלול‪ ,‬המערכת‬ ‫בודקת אם המסלול נבנה בצורה חוקית (שהמסלול סגור‪ ,‬ושאין מקום בו הכביש לא מחובר)‪ .‬לאחר‬ ‫מכן ניתנת למשתמש אפשרות לשמור את המסלול שבנה לקובץ‪ ,‬וכמובן גם לטעון מסלול מקובץ‬ ‫קיים‪ .‬בנוסף‪ ,‬הוא גם יכול לערוך מסלול קיים‪ .‬ה‪ SimuLAWtor Editor -‬מאפשר גם לייצא‪/‬לייבא‬ ‫מסלול ל‪/‬מקובץ ‪.XML‬‬ ‫קיימים כמה דברים נוספים השייכים לתחום בו עסק בפרויקט הראשון‪ ,‬ה‪ ,SimuLAWtor -‬ושופרו‬ ‫בפרויקט הנוכחי‪:‬‬ ‫‪‬‬ ‫‪‬‬ ‫‪‬‬

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

‫ה‪ ,SimuLAWtor Editor-‬מורכב משני חלקים‪:‬‬ ‫‪‬‬ ‫‪‬‬

‫החלק הראשון‪ ,‬האחראי על בניית המסלול עצמו‪ ,‬נבנה בסביבת ה‪.Second Life -‬‬ ‫החלק השני‪ ,‬מהווה מעין מסגרת לחלק הראשון‪ .‬הוא אחראי על כל הפעולות המנהלות את‬ ‫החלק הראשון‪ ,‬כגון‪ :‬שמירה‪/‬טעינה‪/‬עריכה של מסלולים‪ .‬חלק זה הינו אפליקציית ‪JAVA‬‬ ‫המתקשרת עם החלק הראשון‪ ,‬שכאמור יושב בתוך עולם ה‪.Second Life -‬‬

‫התקשורת בין שני החלקים‪ ,‬מתבצעת באמצעות טכנולוגיה הנקראת ‪ ,XML-RPC‬המאפשרת לשלוח‪,‬‬ ‫במקרה זה מאפליקציית ה‪ HTTP Request ,JAVA-‬ל‪ Prim-‬שרוצים בתוך ‪ ,Second Life‬ולקבל ממנו‬ ‫תשובה חזרה‪ .‬רק הצד של אפליקציית ה‪ JAVA-‬יכול ליזום את התקשורת‪ .‬ה‪ Prim-‬הנמצא בסביבת‬ ‫ה‪ Second Life-‬יכול רק לענות לבקשה זו‪ ,‬אך לא ליזום בעצמו תקשורת‪ ,‬דבר שהקשה לא פעם על‬ ‫תיכון הפרויקט‪.‬‬

‫‪14‬‬


‫מקורות‬ ‫במהלך הפרויקט נעזרתי בשני אתרים המרכזים את כל המידע על כל הפקודות הקיימות בשפת ה‪-‬‬ ‫‪:LSL‬‬ ‫‪http://lslwiki.net‬‬ ‫‪http://wiki.secondlife.com/wiki/LSL_Portal‬‬ ‫בנוסף‪ ,‬כדי לחקור מה אילו מוצרים כבר קיימים בתחום‪ ,‬השתמשתי באתר הבא‪ ,‬המכיל הרבה‬ ‫קישורים לפרויקטים שונים שנעשו‪:‬‬ ‫‪http://www.cem.inrets.fr/ur/sara/Pg_simus_e.html‬‬

‫‪15‬‬


‫רקע על סביבת העבודה‬ ‫ראשית‪ ,‬נבהיר מספר דברים לגבי אופן העבודה בסביבת ה‪:Second Life -‬‬ ‫הסביבה מאפשרת לבנות גופים תלת ממדיים‪ ,‬המורכבים מאובייקטים ( ‪ )Prims‬המחוברים אחד‬ ‫לשני‪ .‬כל אובייקט יכול להכיל קטע קוד אחד או יותר‪ ,‬אותם הוא מבצע לכל אורך קיומו‪ .‬קיימת‬ ‫אפשרות גם שאובייקט אחד ייצור אובייקט אחר‪ .‬לשם כך‪ ,‬האובייקט היוצר צריך להכיל בתוכו את‬ ‫האובייקט הנוצר‪.‬‬ ‫צורת הניהול של האובייקטים היא לא חכמה מספיק‪ ,‬וגורמת לחלק גדול מהעבודה להיות בעצם‬ ‫"עבודה שחורה"‪ .‬להלן מספר דוגמאות‪:‬‬ ‫‪‬‬

‫‪‬‬

‫נניח שקיים אובייקט ‪ ,A‬שיוצר אובייקט אחר ‪ ,B‬שיוצר אובייקט אחר ‪ .C‬במידה ונרצה לשנות‬ ‫משהו באובייקט ‪ ,C‬לאחר השינוי נצטרך לקחת עותק מאותו אובייקט ‪ C‬חדש (לאחר‬ ‫השינוי)‪ ,‬ולהחליף אותו עם זה שכבר קיים באובייקט ‪ .B‬מכיוון שכך גם גרמנו לשינוי‬ ‫באובייקט ‪ ,B‬נצטרך להחליף אותו עם זה שכבר קיים בתוך אובייקט ‪ .A‬דבר זה גורם‬ ‫לסרבול מיותר‪ ,‬גם אם השינוי שאנו רוצים לבצע הוא מזערי ביותר‪.‬‬ ‫ברוב זמן העבודה על הפרויקט‪ ,‬ברגע שכמה אובייקטים ביו מחוברים יחד‪ ,‬ההתייחסות‬ ‫הייתה אך ורק לאובייקט המאוגד‪ ,‬ולא ניתנה גישה לאובייקט ספציפי המוכל בו‪ .‬לכן‪ ,‬כל פעם‬ ‫שהיה צריך לשנות את אחד האובייקטים המרכיבים את האובייקט המאוגד‪ ,‬היה צריך‬ ‫להפריד את כל האובייקטים‪ ,‬לבצע את השינוי הרצוי‪ ,‬ולחבר את כולם חזרה‪ .‬סדר סימון‬ ‫האובייקטים לפני חיבורם אחד לשני הינו בעל משמעות רבה (אם זה בהתייחסות לכל‬ ‫אובייקט בקוד‪ ,‬או קביעת האובייקט המרכזי של אותו גוף מאוגד)‪ ,‬דבר שהקשה עוד יותר על‬ ‫פעולה זו‪ .‬חשוב לציין שלקראת סוף העבודה על הפרויקט‪ ,‬יצאה גרסה חדשה ל‪ Viewer -‬של‬ ‫‪ ,Second Life‬שכן אפשרה תכונה זו (גישה לתוך אובייקט ספציפי) והקלה בהרבה על כל‬ ‫התהליך‪.‬‬

‫כתוצאה מעובדות אלו‪ ,‬שיטת העבודה הייתה לבנות אב טיפוס‪ ,‬המכיל אך ורק שלושה חלקי כביש‬ ‫שונים (יפורט בפרק היישום)‪ ,‬להגיע לשלב המאוד סופי של הפרויקט‪ ,‬ורק אז להוסיף את חלקי‬ ‫הכביש האחרים‪ .‬זאת מתוך ידיעה שלא הכל יעבוד על הפעם הראשונה‪ ,‬ורצון לחסוך כמה שיותר‬ ‫ב"עבודה שחורה"‪.‬‬ ‫התקשורת בין האובייקטים בסביבת ה‪ Secons Life -‬מתבצעת בשיטה של הודעות (‪.)Messaging‬‬ ‫קיים מספר גדול של ערוצים‪ .‬כל הודעה הנשלחת מאובייקט מסוים‪ ,‬נשלחת על גבי ערוץ שנבחר ע"י‬ ‫המפתח‪ .‬כדי שאובייקט יקבל את אותה הודעה‪ ,‬הוא צריך להיות במצב של האזנה לאותו ערוץ‪.‬‬ ‫כשאובייקט מזהה הודעה בערוץ אליו הוא מאזין‪ ,‬מופעל אצלו טריגר‪ ,‬שהוא בעצם כניסה לפונקציה‬ ‫המכילה את פרטי ההודעה שהתקבלה‪ .‬כך האובייקטים מדברים אחד עם השני‪ ,‬ועל עקרון זה‬ ‫מבוססת כל התקשורת בחלק זה של הפרוייקט‪.‬‬ ‫בצד של אפליקציית ה‪ JAVA-‬נמצאה ברשת (באתר של חברת ‪ )SUN‬דוגמא לאפליקציה שיודעת‬ ‫לשמור ולטעון קובץ‪ .‬על אפליקציה זו הולבש כל חלק זה של הפרויקט‪ .‬מומשו פעולות השמירה‬ ‫והטעינה בהתאם לאובייקטים ב‪ ,Second Life -‬והוספו תכונות חדשות‪ .‬כמובן שגם הוספה‬ ‫לאפליקציה התמיכה בטכנולוגית ה‪ XML-RPC -‬שתוארה בפרק המבוא‪ ,‬לצורך אפשור תקשורת עם‬ ‫האובייקטים ב‪.Second Life-‬‬

‫‪16‬‬


‫לצורך העבודה על הפרויקט‪ ,‬היה צורך ללמוד את שפת ה‪ LSL -‬לעומקה‪ ,‬וכן ללמוד על טכנולוגית ה‪-‬‬ ‫‪ XML-RPC‬ואופן השימוש בה‪.‬‬ ‫לצורך הפעלת ה‪ -‬ה‪ SimuLAWtor Editor-‬יש ליצור משתמש בעולם ה‪ Second Life-‬דרך הקישור‬ ‫הבא‪https://join.secondlife.com/?lang=en-US :‬‬ ‫בנוסף‪ ,‬יש להתקין את תוכנת ה‪ Viewer -‬של ‪ Second Life‬מהקישור הבא‪:‬‬ ‫‪http://secondlife.com/support/downloads/?lang=en-US‬‬

‫ההרשמה וההתקנה‪ ,‬שתיהן בחינם‪.‬‬ ‫לאחר מכן‪ ,‬יש להגיע לאי הפיתוח של שנקר‪ ,‬שם נמצא הפרויקט (אובייקט בצורה של מכבש)‪.‬‬ ‫בשלב זה יש להפעיל את אפליקציית ה‪ )SLClient( JAVA -‬ולהתחיל לעבוד‪.‬‬

‫‪17‬‬


‫היישום‬ ‫כפי שנכתב בפרקים הקודמים‪ ,‬הפרויקט בנוי משני חלקים‪ ,‬אפליקציית ‪ JAVA‬המתקשרת עם‬ ‫אובייקט בסביבת ה‪ .)SLClient( Second Life-‬ראשית נתאר בקצרה מה כולל כל חלק‪ ,‬וכן נפרט לגבי‬ ‫שלבי הפעולה של כל תכונה של הפרויקט‪.‬‬ ‫האובייקט בסביבת ה‪ Second Life-‬הוא אובייקט מערכת שתפקידו לקבל הודעות מאפליקציית ה‪-‬‬ ‫‪ JAVA‬ולנהל בהתאם לכך את מה שקורה בעולם ה‪.Second Life-‬‬ ‫‪ SLClient‬הינה אפליקציה קטנה‪ ,‬המתקשרת עם אובייקט המערכת בעולם ה‪ .Second Life -‬עם‬ ‫הפעלת ה‪ SLClient-‬נוצר אובייקט מסוג ‪ Track‬המכיל מערך של אובייקטים מסוג ‪( Square‬ניתן‬ ‫לראות דיאגראמת ‪ UML‬בסוף פרק זה)‪ SLClient .‬מכילה‬ ‫את הכפתורים הבאים‪:‬‬ ‫‪ – New‬בעת לחיצה על הכפתור‪ ,‬המשתמש נשאל שאלה‬ ‫לגבי גודל המסלול הרצוי‪ .‬הוא מכניס את מספר המשבצות‬ ‫שהוא רוצה שיהיו לאורך ולרוחב‪ ,‬ומאשר את ההודעה‪.‬‬ ‫בשלב זה נשלחת הודעה לאובייקט המערכת‪ ,‬והוא יוצר לוח‬ ‫של משבצות ריקות בגודל המבוקש‪ .‬על כל אחת‬ ‫מהמשבצות יש שלושה כפתורים‪ ,Left ,Right :‬ו‪.Rotation-‬‬ ‫‪ Right‬ו‪ Left-‬מחליפים בין הריבועים האפשריים (כביש ישר‪,‬‬ ‫פנייה שמאלה‪/‬ימינה‪ ,‬צומת וכו')‪ .‬ה‪ ,Rotation -‬תפקידו‬ ‫לשנות את כיוון הריבוע ע"י סיבובו ב‪ 90 -‬מעלות עם כל‬ ‫לחיצה‪.‬‬

‫איור ‪ - 2‬אפליקצית ‪SLClient‬‬

‫‪ – Finalize‬תפקיד כפתור זה הוא למשוך את פרטי‬ ‫המסלול מאובייקט המערכת‪ ,‬לבדוק את חוקיותו‪ ,‬ולהכין‬ ‫את המסלול לשימוש‪ .‬לאחר שהמשתמש סיים לבנות‬ ‫את המסלול ע"י בחירת המשבצות וכיוונן‪ ,‬הוא לוחץ על‬ ‫כפתור זה‪ .‬בשלב זה‪ ,‬נשלחת הודעה לאובייקט‬ ‫המערכת‪ ,‬המורה לו לשמור את פרטי המסלול‪ .‬כדי‬ ‫לעשות זאת‪ ,‬הוא שולח בלולאה הרצה מ‪ 0 -‬עד מספר‬ ‫המשבצות בלוח פחות ‪ ,1‬שאלה לכל אחת ממשבצות‬ ‫הלוח‪ .‬כל משבצת עונה לו את שמו וכיוונה‪ .‬המסלול‬ ‫נשמר באובייקט המערכת בשני ‪-LIST‬ים‪ LIST .‬אחד שומר את שמות המשבצות‪ ,‬והשני שומר את‬ ‫כיווניהן בהתאמה ( ‪ .)N,W,S,E‬לדוגמא‪ ,‬במצב שהמשבצת השלישית בלוח מכילה חלק מסוג סיבוב‬ ‫וכיוונה הוא מערב‪ ,‬יתקיים‪:‬‬ ‫איור ‪ - 3‬מצב בניית המסלול‬

‫"‪Squares[2]="Curve‬‬ ‫"‪Directions[2]="W‬‬

‫‪18‬‬


‫לאחר שאובייקט המערכת מסיים לשמור את פרטי המסלול בשני ה‪-LIST -‬ים‪ ,‬הוא שולח הודעה ל‪-‬‬ ‫‪ ,SLClient‬וזאת מתחילה לקרוא ממנו בלולאה שרצה על כל אחד מאיברי שני ה‪-LIST -‬ים את פרטי‬ ‫המסלול‪ .‬פרטי המסלול נשמרים במערך ה‪ Squares-‬של אובייקט ה‪.Track-‬‬ ‫לאחר מכן‪ SLClient ,‬מריצה על המערך פונקציה‬ ‫הבודקת את תקינות המסלול‪ .‬קיימים שני תנאים‬ ‫לתקינותו של המסלול‪:‬‬ ‫‪‬‬ ‫‪‬‬

‫המסלול סגור‪.‬‬ ‫קיים חלק ‪ Start‬אחד ויחיד‪.‬‬

‫במידה והמסלול לא תקין‪ ,‬תשלח הודעה לאובייקט‬ ‫המערכת בסביבת ה‪ Second Life-‬עם מספר‬ ‫המשבצת הבעייתית‪ ,‬וזאת תיצבע באדום‪ .‬המשתמש‬ ‫אז יוכל לתקן את המסלול‪.‬‬ ‫במידה והמסלול חוקי‪ ,‬המשתמש ישאל למספר‬ ‫הסיבובים ��שר הוא רוצה לקבוע למסלול‪ .‬לאחר‬ ‫שיענה‪ ,‬ה‪ SLClient-‬ישלח הודעה עם מידע זה‬ ‫לאובייקט המערכת‪ .‬אובייקט המערכת יעדכן אצלו את‬ ‫מספר הסיבובים‪ ,‬וישלח מידע זה לחלק ה‪.Start -‬‬ ‫כהכנת המסלול לנהיגה‪ ,‬אובייקט המערכת ישלח‬ ‫הודעה לכל חלקי המסלול‪ ,‬כדי שיעלימו את כפתורי‬ ‫העריכה (הכפתורים לא באמת ייעלמו‪ ,‬אלא פשוט‬ ‫יעטה על עצמו ‪ Texture‬שקוף)‪ ,‬ויהפכו אותם ללא‬ ‫פעילים‪ .‬בנוסף‪ ,‬חלק ה‪ Start-‬במסלול ייצור עליו את‬ ‫המכונית בה המשתמש יוכל לנהוג מרגע זה‪.‬‬

‫איור ‪ - 4‬מציאת חלק לא חוקי במהלך בדיקת חוקיות‬ ‫המסלול‬

‫איור ‪ - 5‬לאחר שהמסלול נמצא חוקי‪ ,‬נעלמיםכפתורי‬ ‫העריכה ומופיעה המכונית‪ .‬אפשר להתחיל לנהוג‬

‫‪ – Save‬כפתור זה נועד כדי לשמור את המסלול‪ .‬לחיצה עליו לוקחת את אובייקט המסלול הנוכחי‬ ‫(שנשמר לאחר פעולת ה‪ Finalize-‬שבוצעה קודם לכן) וכותבת אותו לתוך קובץ בינארי‪.‬‬ ‫‪ – Load‬כפתור זה נועד כדי לטעון מסלול מקובץ קיים‪ .‬לחיצה עליו נותנת למשתמש לבחור קובץ‬ ‫מהדיסק‪ .‬לאחר בחירת הקובץ‪ SLClient ,‬קוראת את הקובץ הבינארי‪ ,‬וכותבת את נתוניו לתוך‬ ‫אובייקט ה‪ .Track-‬לאחר מכן היא שולחת הודעה לאובייקט המערכת ב‪ ,Second Life -‬המודיעה לו‬ ‫שהוא הולך לקבל מסלול לבנייה‪ ,‬ובתוך הודעה זו קיים גם מידע על גודל המסלול‪ ,‬שאובייקט‬ ‫המערכת מעדכן אצלו‪ .‬ה‪ SLClient-‬שולח לאובייקט המערכת אז בלולאה את המידע לגבי כל חלקי‬ ‫המסלול‪ ,‬וזה מעדכן אותם בשני ה‪-LIST -‬ים שלו המיועדים לכך‪ .‬לאחר מכן‪ ,‬הוא מתחיל לבנות את‬ ‫המסלול תוך כדי ריצה על שני ה‪-LIST -‬ים (המכילים כעת את השם והכיוון של כל משבצות המסלול)‪.‬‬ ‫לאחר סיום הבניה‪ ,‬מתבצע אותו שלב הכנת המסלול שתואר קודם לכן‪ ,‬בשלב ה‪( Finalize -‬החבאת‬ ‫כפתורי העריכה ויצירת המכונית‪.‬‬ ‫‪ – Edit‬מטרת כפתור זה היא לתת למשתמש לערוך מסלול קיים‪ ,‬משמע מסלול שעכשיו טען מקובץ‪,‬‬ ‫או מסלול שכבר ביצע לו ‪ ,Finalize‬והוא רוצה כעת לבצע בו שינויים‪.‬‬

‫‪19‬‬


‫‪ – Clear‬מטרת כפתור זה היא למחוק את כל חלקי המסלול הנמצאים כעת בסביבת ה‪.Second Life -‬‬ ‫לחיצה עליו שולחת הודעה לאובייקט המערכת ב‪ Second Life -‬ששולח הודעה לכל החלקים במסלול‬ ‫שייעלמו (יימחקו לגמרי)‪.‬‬ ‫‪ – Export to XML‬מטרת כפתור זה היא להמיר את המסלול הקיים לפורמט של ‪ XML‬ולשמור אותו‬ ‫לקובץ‪ .‬לחיצה עליו מייצרת קובץ ‪ XML‬חדש עם שם שהמשתמש בחר‪ ,‬המכיל את כל פרטי המסלול‪.‬‬ ‫‪ – Import XML‬מטרת כפתור זה היא לייבא מסלול מקובץ ‪ XML‬קיים‪ .‬לחיצה עליו נותנת למשתמש‬ ‫לבחור קובץ ‪ XML‬מהדיסק‪ ,‬ממירה אותו לאובייקט מסלול‪ ,‬וכותבת אותו לקובץ בינארי‪.‬‬

‫איור ‪ Class Diagram - 6‬של אובייקט המערכת ב‪SL-‬‬

‫‪20‬‬


SLClient UML Diagram - 7 ‫איור‬

21


‫בדיקות‪ ,‬תוצאות והערכה‬ ‫להלן תרחישי הבדיקה שהתבצעו במטרה לאמוד את איכות היישום‪:‬‬ ‫בדיקת התקשורת בין ה‪ SLClient -‬לאובייקט המערכת ב‪:Second Life-‬‬ ‫יכולות בסיסיות‬ ‫‪‬‬ ‫‪‬‬ ‫‪‬‬ ‫‪‬‬ ‫‪‬‬ ‫‪‬‬

‫יצירה של מסלול חדש – נמצא תקין‪.‬‬ ‫שמירת מסלול לקובץ – נמצא תקין‪.‬‬ ‫בדיקת חוקיותו של מסלול חוקי – נמצא תקין‪.‬‬ ‫בדיקת חוקיותו של מסלול לא חוקי – נמצא תקין‪.‬‬ ‫עריכת מסלול קיים ושמירתו מחדש – נמצא תקין‪.‬‬ ‫ניקיון סביבת העבודה (ע"י שימוש בכפתור ‪ – )Clear‬נמצא תקין‪.‬‬

‫תשתית ליכולות עתידיות (להרחבה)‬ ‫‪‬‬ ‫‪‬‬

‫ייצוא מסלול לקובץ ‪ – XML‬נמצא תקין‪.‬‬ ‫ייבוא מסלול מקובץ ‪ – XML‬נמצא לא תקין‪.‬‬

‫בדיקות בתוך סביבת ה‪ Second Life-‬של המסלול הנוצר‪:‬‬ ‫‪‬‬ ‫‪‬‬

‫נסיעת מבחן עם המכונית‪ ,‬כדי לוודא את תקינות ספירת הסיבובים של המסלול – נמצא‬ ‫תקין‪.‬‬ ‫בדיקות תקינות האלמנטים האחראים על הציות לחוקי התנועה (הצומת המרומזר‪ ,‬תמרור‬ ‫העצור‪ ,‬התמרור האוסר על פניה שמאלה‪ ,‬ומעבר החצייה – נמצאו תקינים‪.‬‬

‫‪22‬‬


‫מסקנות ופיתוחים עתידיים‬ ‫התוצר הסופי של פרויקט זה הוא אפליקציית ‪ JAVA‬השולטת מרחוק על הנעשה בעולם ה‪Second -‬‬ ‫‪ .Life‬האפליקציה מאפשרת ליצור מסלולי נהיגה בסביבה תלת ממדית‪ ,‬עם מתן דגש על ציות לחוקי‬

‫התנועה השונים‪ .‬ניתן לשמור מסלולים אלו ולטעון אותם מחדש‪.‬‬ ‫הפרויקט נמצא עובד תקין‪.‬‬ ‫לאחר בדיקה ברשת‪ ,‬נמצא כי קיימים פרויקטים דומים‪ ,‬אך אף אחד מהם לא מספק את מלוא‬ ‫התכונות של פרויקט זה‪ .‬פרויקט אחד שנמצא מכיל מסלול מוכן‪ ,‬ובעצם מזכיר בתוכנו את הפרויקט‬ ‫הראשון‪ ,‬שפרויקט זה הוא ההמשך שלו‪ .‬פרויקט נוסף שנמצא ברשת‪ ,‬מכיל ממשק עריכה של מסלולי‬ ‫נהיגה תלת ממדיים‪ ,‬הכוללים תמרורים שונים‪ ,‬אך לא מוזכר בו דבר על הציות לאותם תמרורים‪.‬‬ ‫משמע‪ ,‬אין אף אזכור לתגובת המערכת חזרה למשתמש‪ ,‬במידה וביצע עבירת תנועה‪.‬‬ ‫קיימים מספר כיוונים לפיתוח נוסף של הפרויקט‪:‬‬ ‫‪‬‬ ‫‪‬‬ ‫‪‬‬

‫‪‬‬

‫הוספת אפשרות של ריבוי משתמשים במסלול‪ .‬הכוונה ליכולת של שתי מכוניות ויותר לנסוע‬ ‫על אותו מסלול‪ .‬אולי אפילו מכונית המופעלת ע"י המערכת‪.‬‬ ‫הטמעת אפליקציית ה‪ JAVA-‬בתוכנת ה‪ Viewer-‬של ‪ ,Second Life‬והפיכת הפרויקט למקשה‬ ‫אחת‪ .‬דבר זה הוא אפשרי‪ ,‬משום שתוכנת ה‪ Viewer -‬של ‪ Second Life‬כתובה בקוד פתוח‪.‬‬ ‫אפשרות נוספת‪ ,‬הסותרת את קודמתה‪ ,‬היא למצוא סביבה תלת ממדית אחרת מזאת של‬ ‫‪ ,Second Life‬משום שסביבה זו לא מתאימה לפיתוח של פרויקטים ברמת מורכבות של‬ ‫פרויקט זה‪ .‬אמנם זאת פלטפורמה המקלה על הפיתוח בכך שהיא נותנת סביבה וכלים‬ ‫מוכנים מראש‪ ,‬אך כפי שהוזכר בפרק השיטות‪ ,‬קיימים יחד עם זאת הרבה מכשולים‬ ‫"מיותרים" המפריעים לפעמים לבצע את הפעולות הכי פשוטות (לדוגמא‪ :‬הכלת אובייקטים‬ ‫אחד בתוך השני‪ ,‬או מחסור במגוון של מבני נתונים שונים)‪.‬‬ ‫תצוגה של קבצי המסלולים השמורים טרם פתיחתם‪ .‬באמצעות גרסת ה‪ XML -‬של המסלול‪,‬‬ ‫ניתן להציגו באמצעות טבלה בדף ‪.HTML‬‬

‫‪23‬‬


Abstract The SimuLAWtor Editor is a construction interface for driving tracks in a threedimensional virtual environment, including elements that combine monitoring compliance to traffic laws. The project approach rehabilitated drivers who lost their driving skills, but also diverse populations such as children, youth faced with receiving a driver's license, or anyone else who wants to experience a virtual driving environment. Interface composed of two parts. The first is a component in Second Life environment (a platform that runs a three-dimensional virtual world), that responsible for building the trucks. The second one is a Java application that links between the user actions and the components in Second Life. Key features of the interface are creating, saving and loading of these tracks. These actions are carried out by the passage of messages between the Java application and the connecting element in Second Life. After creating a track, system checks if the track is legal. If so, the user can save it to a binary file. The user can also load an existing track from a file, and edit it. The track is done by creating a panel layout with empty slots first. Each slot has edit buttons, through which the user selects the type of road and its direction. Communication between objects on the Second Life environment is based on the principle of transferring messages from one to another. The Java application has a central object Track, contains an array of Square objects. That object pulls the current track information from Second Life environment, and saves all its details. Tests at the end of the work on the project showed that all the features were working properly. However, there is much room for improvement and expansion of the project; Such as moving it to another development environment, because Second Life environment is not appropriate for projects of that size. It will also combine the two parts of the project, which will improve the intuitive level of it. During the project, drawn several conclusions about the Second Life environment. The first is that environment is not completely closed, allowing developing of utilities to a rule it from the outside. However, the second conclusion is that the environment is not suitable for developing systems of this size, but the development of smaller applications, which not require execution of complex algorithms. A good example of this is the lack of the Array data structure, which is a basic tool in many developing techniques.

24


Shenkar Collage of Engineering and Design Faculty of Engineering Department of Software Engineering

SimuLAWtor Editor Final project By Igar Ben-Tal Advisor: Dr. Yesha Sivan Submitted as Part of the Requirements for receiving Bachelor of Science degree (B.Sc.)

15.10.2010

25


SimuLAWtor Editor - Document