כיצד לתכנת משחקי מחשב (עם תמונות)

2024 מְחַבֵּר: Robert Blare | [email protected]. שונה לאחרונה: 2024-01-31 12:16

יש לכם רעיון למשחק מחשב ורוצים להפוך אותו לאמיתי? או שתהיתם פעם איך כותבים משחקי מחשב? WikiHow זה מלמד אותך כיצד לכתוב שלושה משחקי מחשב בסיסיים בפייתון. תזדקק להבנה בסיסית של Python ומושגי תכנות כללי כדי לפתח את המשחק הראשון שלך.

צעדים

חלק 1 מתוך 3: יצירת משחק מבוסס טקסט

שלב 1. בחר שפת תכנות

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

• למה משמשת השפה בעיקר?

  חלק משפות התכנות, כמו JavaScript, מיועדות לשימוש באינטרנט, בעוד שאחרות, כמו Python, C או C ++, מיועדות להפעלת תוכנות מחשב. למשחק שלך, שאף לשפה עם מגוון רחב יותר של שימוש, כגון Python, C, C ++, או JavaScript.

• כמה קשה ללמוד?

  למרות שכתיבת תוכנית אמורה להיות קלה מספיק לאחר תרגול כלשהו בשפת תכנות רגילה (כלומר, לא כזו שתוכננה במיוחד לבלבל כמו Malbolge), חלקם ידידותיים יותר למתחילים מאחרים. Java ו- C, למשל, יחייבו אותך להבין מושגי תכנות עמוקים יותר מאשר משהו כמו Python, הידוע בתחבירו הנגיש והפשוט יותר.

• היכן אוכל להשתמש בו?

  אתה כנראה רוצה שאנשים במערכות שונות, כגון Linux, Mac או Windows, יוכלו לשחק את המשחק שלך. אז אתה לא צריך להשתמש בשפה הנתמכת רק בכמה מערכות, כמו Visual Basic, הנתמכת רק ב- Windows.

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

שלב 2. הכינו את המחשב

שני המרכיבים העיקריים שתזדקקו להם הם עורך טקסט, בו תכתבו את הקוד שלכם, ומהדר, בו תוכלו להשתמש כדי להפוך אותו למשחק. אם אתה רוצה לעקוב אחר הדוגמה במאמר זה, עליך להתקין את פייתון וללמוד כיצד להריץ תוכניות. אם תרצה, תוכל להגדיר IDE (Desktop Integrated Desktop Environment), המשלב עריכה, הידור וניקוי באגים לתוכנית אחת. ה- IDE של Python נקרא IDLE. אבל אתה יכול פשוט להשתמש בכל עורך טקסט התומך בטקסט רגיל, כגון פנקס רשימות עבור Windows, TextEdit עבור macOS או Vim עבור Linux.

שלב 3. כתוב קוד כלשהו לברך את השחקן

השחקן ירצה לדעת מה קורה ומה עליו לעשות, לכן עליך להדפיס עבורו טקסט.

• זה נעשה בעזרת הפונקציה print () ב- Python. כדי לנסות זאת, פתח קובץ חדש עם סיומת.py, הזן את הקוד הבא, שמור והפעל אותו:

  הדפס ("ברוכים הבאים למשחק הניחושים במספרים!") הדפס ("הזן מספר שלם בין 1 ל -1000:")
  

שלב 4. צור מספר אקראי

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

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

• השתמש בפונקציה אקראית. הוא נקרא randint (), נמצא בספרייה האקראית שזה עתה ייבאת, ולוקח את הערך המינימלי והמקסימלי שיש למספר כארגומנט. אז חזור לסוף הקוד שלך והזן את השורה הבאה:

  rightNum = random.randint (0, 1000)
  

שלב 5. קבל קלט מהנגן

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

• מכיוון שהקוד שהזנת מדפיס את ההוראה להזנת מספר לשחקן, עליו לקרוא גם את המספר שהם מכניסים. זה נעשה עם קלט () ב- Python 3, ו- raw_input () ב- Python 2. כדאי לכתוב ב- Python 3, מכיוון ש- Python 2 יתיישן בקרוב. הוסף את השורה הבאה לקוד שלך כדי לאחסן את קלט השחקן במשתנה הנקרא מספר:

  userNum = input ()
  

שלב 6. הפוך את קלט הנגן לסוג נתונים שמיש

השחקן הזן מספר-מה עכשיו?

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

  userNum = int (userNum)
  

שלב 7. השווה את מספר השחקן למספר הנכון

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

בעוד userNum! = rightNum: userNum = int (קלט ())

שלב 8. תן לשחקן משוב

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

• אין ספק שאתה יכול להגיד לשחקן אם המספר שלו נכון או לא נכון. אבל עם גישה זו, ייתכן שהשחקן יצטרך לנחש 1000 פעמים במקרה הגרוע ביותר, וזה יהיה משעמם מאוד.
• אז ספר לשחקן אם מספרם קטן מדי או גדול מדי. זה יקטין את מספר הניחושים שלהם באופן משמעותי. אם, למשל, השחקן מנחש קודם כל 500, והמשחק עונה "גדול מדי. נסה שוב", יהיו רק 500 מספרים אפשריים במקום 1000. הדבר נעשה עם if-constructions, אז החלף את ההדפס ("שגוי. נסה שוב. ") עם אחד.
• שים לב שבדיקת אם שני מספרים זהים נעשית עם ==, לא עם =. = מקצה את הערך הימני שלו למשתנה השמאלי ממנו!

אם userNum <rightNum: print ("קטן מדי. נסה שוב:") אם userNum> rightNum: print ("גדול מדי. נסה שוב:")

שלב 9. בדוק את הקוד שלך

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

• כאשר מתכנתים בפייתון, ודא שאתה מקבל את החריצים הנכונים. הקוד שלך אמור להיראות כך:

  יבוא הדפסה אקראית ("ברוכים הבאים למשחק הניחושים במספרים!") הדפס ("הזן מספר שלם בין 1 ל -1000:") rightNum = random.randint (0, 1000) userNum = input () userNum = int (userNum) בעוד userNum! = rightNum: אם userNum <rightNum: print ("קטן מדי. נסה שוב:") אם userNum> rightNum: print ("גדול מדי. נסה שוב:") userNum = int (input ()) print ("ניחשת נכונה.")
  

שלב 10. אמת את הקלט

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

• פתח את המשחק שוב ונסה להזין כל דבר שאינו מספר. המשחק ייצא עם ValueError. כדי להימנע מכך, תוכל ליישם דרך לבדוק האם הקלט היה מספר.
• הגדר פונקציה. מכיוון שאימות הקלט ארוך למדי, ועליך לעשות זאת מספר פעמים, עליך להגדיר פונקציה. זה לא ייקח טיעונים ויחזיר מספר. ראשית, כתוב def numInput (): בחלק העליון של הקוד שלך, ישירות מתחת לאקראי הייבוא.
• קבל את קלט השחקן פעם אחת. השתמש בפונקציית הקלט () והקצה את התוצאה למשתנה inp.
• כאשר קלט השחקן אינו מספר, בקש מהם להזין מספר. כדי לבדוק אם מחרוזת היא מספר, השתמש בפונקציות isdigit (), המאפשרות רק מספר שלם, כך שלא תצטרך לבדוק זאת בנפרד.
• אם הקלט הוא מספר, המר אותו ממחרוזת למספר והחזר את התוצאה. השתמש בפונקציה int () להמרת המחרוזת למספר שלם. זה יהפוך את ההמרה בקוד הראשי למיותר, וכדאי להסיר אותה משם.
• החלף את כל השיחות לקלט () בקוד הראשי בקריאות ל- numInput ().
• הקוד של הפונקציה numInput () ייראה כך:

def numInput (): inp = input () while not inp.isdigit (): print ("אמרו לך להזין מספר שלם! הזן מספר שלם:") inp = input () return int (inp)

שלב 11. בדוק את המשחק שוב

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

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

שלב 12. מציע להפעיל מחדש את המשחק בסיומו

בדרך זו, השחקן יוכל לשחק את המשחק שלך למשך זמן רב יותר מבלי להפעיל אותו כל הזמן.

• הכנס את כל הקוד למעט הייבוא והגדרת הפונקציה ללולאת זמן. הגדר נכון כתנאי: זה תמיד יהיה נכון, כך שהלולאה תימשך לנצח.
• שאל את השחקן אם הוא רוצה לשחק שוב לאחר שניחשו נכון את המספר. השתמש בפונקציה print ().
• אם הם עונים "לא", פרצו מהמבט. אם הם עונים על משהו אחר, המשך. פריצת הלולאה מתבצעת באמצעות הצהרת ההפסקה.
• העבר את "ברוכים הבאים למשחק הניחושים במספרים" אל מחוץ ללולאת ה- while. השחקן כנראה לא רוצה להתקבל בברכה בכל פעם שהוא משחק את המשחק. העבר את הדפס ההוראות ("ברוכים הבאים למשחק הניחושים במספרים!" מעל נכון בזמן:, כך שהוא יודפס רק פעם אחת, כאשר המשתמש יתחיל את המשחק הראשון.

שלב 13. בדוק את המשחק

יהיה עליך לבדוק את המשחק שלך בכל פעם שאתה מיישם תכונה חדשה.

• הקפד לענות על "כן" ו"לא "לפחות פעם אחת כדי לוודא ששתי האפשרויות פועלות. כך צריך להיראות הקוד שלך:

  יבוא def def randomInput (): inp = input () בעוד לא inp.isdigit (): print ("אמרו לך להזין מספר שלם! הזן מספר שלם:") inp = input () return int (inp) print ("ברוכים הבאים למשחק ניחוש המספרים!") בעוד נכון: הדפס ("הזן מספר שלם בין 1 ל -1000:") rightNum = random.randint (0, 1000) userNum = numInput () בעוד userNum! = RightNum: if userNum <rightNum: print ("קטן מדי. נסה שוב:") אם userNum> rightNum: print ("גדול מדי. נסה שוב:") userNum = numInput () הדפס ("ניחשת נכון.") הדפס ("האם אתה? רוצה לשחק שוב? הזן לא להפסיק. ") אם קלט () ==" לא ": הפסקה
  

שלב 14. כתוב משחקים אחרים המבוססים על טקסט

מה דעתך לכתוב הרפתקה טקסט הבאה? או משחק חידון? תהיה יצירתי.

עֵצָה: לפעמים מועיל לחפש בתיעוד אם אינך בטוח כיצד נעשה משהו או כיצד משתמשים בפונקציה. תיעוד Python 3 נמצא בכתובת https://docs.python.org/3/. לפעמים חיפוש מה שאתה רוצה לעשות באינטרנט גם מחזיר תוצאות טובות.

חלק 2 מתוך 3: יצירת משחק עם גרפיקה דו -ממדית

שלב 1. בחר ספריית גרפיקה

הכנת גרפיקה מסובכת מאוד, ורוב שפות התכנות (כולל Python, C ++, C, JavaScript) מספקות תמיכה מינימלית או אפילו ללא גרפיקה בליבה או בספריות הסטנדרטיות. אז תצטרך להשתמש בספרייה חיצונית כדי ליצור גרפיקה, למשל Pygame for Python.

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

מאמר זה ישתמש ב- Python עם Cocos2D כדי להראות כיצד להכין פלטפורמת 2D פשוטה. ייתכן שחלק מהמושגים שהוזכרו אינם קיימים במנועי משחק אחרים. עיין בתיעוד שלהם למידע נוסף.

שלב 2. התקן את ספריית הגרפיקה שבחרת

קל להתקין את Cocos2D עבור Python. אתה יכול לקבל את זה מ https://python.cocos2d.org/index.html, או על ידי הפעלת sudo pip3 להתקין cocos2d אם אתה משתמש ב- Linux.

שלב 3. צור ספרייה חדשה למשחק ולמדיה שלך

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

שלב 4. צור קובץ קוד חדש בספרייה החדשה

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

בדוגמה זו ניצור קובץ בשם main.py שיכיל את כל הקוד שלנו

שלב 5. צור את חלון המשחק

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

• ייבא את מודולי המשנה הנדרשים של cocos2d: cocos.director, cocos.scene ו- cocos.layer. זה נעשה באמצעות ייבוא subModuleName *, שם שם מודול המשנה הוא מודול המשנה שברצונך לייבא. ההבדל בין … יבוא * ליבוא… הוא שאתה לא צריך לשים את שם המודול מול כל מה שאתה משתמש מהמודול הזה עם הקודם.
• הגדר תת -סוג MainMenuBgr של ColorLayer. זה בעצם אומר שכל רקע בתפריט הראשי שתיצור יתנהג כמו שכבת צבע עם כמה שינויים שתבצע.
• התחל את מנהל קוקוס. זה ייתן לך חלון חדש. אם לא תגדיר כיתוב, החלון יהיה בעל הכיתוב זהה לשם הקובץ (main.py), שלא ייראה מקצועי. אפשר לשנות את גודל החלון על ידי הגדרת שינוי גודל ל- True.
• הגדר פונקציה showMainMenu. עליך להכניס את הקוד להצגת התפריט הראשי לפונקציה מכיוון שזה יאפשר לך לחזור לתפריט הראשי בקלות על ידי קריאה נוספת לפונקציה.
• צור סצנה. הסצנה מורכבת משכבה אחת לעת עתה, שהיא אובייקט במחלקת MainMenuBgr שהגדרת.
• הפעל את הסצנה הזו בחלון.

מייבוא cocos.director * מיבוא cocos.scene * מיבוא cocos.layer * MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenu, self)._ init _ (0, 200, 255, 255) def showMainMenu (): menuSc = Scene (MainMenuBgr ()) director.run (menuSc) director.init (caption = "IcyPlat - פלטפורמה פשוטה", resizable = True) showMainMenu ()

שלב 6. הוסף תפריט ראשי לחלון

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

• ייבא תפריט cocos. (שוב עם הוראת from) ו- pyglet.app (הפעם עם ייבוא).
• הגדר את MainMenu כתת -סוג של תפריט.
• הגדר את היישור של התפריט הראשי. עליך להגדיר את היישור האנכי והאופקי בנפרד.
• צור רשימה של פריטי תפריט והוסף אותם לתפריט. לפחות יהיו פריטי התפריט "התחל משחק" ו- "צא". כל פריט בתפריט צריך להיות ממוקם בתוך סוגריים. על כל פריט להיות בעל תווית ופונקציית התקשרות חוזרת הקובעת מה קורה כאשר השחקן לוחץ עליו. עבור הפריט "התחל משחק", השתמש בפונקציית startGame (אתה תכתוב אותו בקרוב), עבור הפריט "צא" השתמש ב- "pyglet.app.exit" (כבר קיים). צור את התפריט בפועל על ידי התקשרות self.create_menu (menuItems).
• הגדר startGame (). רק הכנס את ההגדרה לעת עתה, אתה תחליף את זה כאשר אתה כותב את המשחק בפועל.
• עבור למקום הקוד שבו יצרת את סצנת menuSc והוסף לו אובייקט MainMenu.

• כל הקוד שלך אמור להיראות כך:

  מיבוא cocos.director * מיבוא cocos.menu * מיבוא cocos.scene * מיבוא cocos.layer * יבוא בכיתה pyglet.app MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) MainMenu בכיתה (תפריט): def _init _ (self): super (MainMenu, self)._ init _ ("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("התחל משחק) ", startGame)), (MenuItem (" Quit ", pyglet.app.exit))] self.create_menu (menuItems) def startGame (): pass def showMainMenu (): menuSc = Scene (MainMenuBgr ()) menuSc.add (MainMenu ()) director.run (menuSc) director.init (caption = "IcyPlat - פלטפורמה פשוטה", resizable = True) showMainMenu ()
  

שלב 7. בדוק את הקוד שלך

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

הקוד מההוראות אמור לפתוח חלון עם הכיתוב "IcyPlat - פלטפורמה פשוטה". הרקע כחול בהיר ותוכל לשנות את גודל החלון. כאשר אתה לוחץ על "התחל משחק" בתפריט, שום דבר לא אמור לקרות (עדיין). כאשר תלחץ על "צא", החלון ייסגר

שלב 8. צור ספרייט

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

• ייבא את מודול המשנה cocos.sprite עם הביטוי מ- import.
• מצא תמונה שתייצג את הספרייט. אינך יכול להציג ספרייט אם אין לך תמונה עבורו. אתה יכול לצייר אחד, או שאתה יכול להשיג אחד מהאינטרנט (היזהר מהרישיונות, אם אתה מתכנן לפרסם את המשחק שלך). בדוגמה זו, עבור אל https://opengameart.org/content/tux-classic-hero-style ושמור את תמונת-p.webp" />
• צור שכבה כאובייקט חדש במחלקה ScrollableLayer. לאחר מכן, צור את ספרייט כאובייקט Sprite והגדר את מיקומו ל- (8, 250). לעיון, הנקודה (0, 0) נמצאת בפינה השמאלית התחתונה. זה די גבוה, אבל זה יוודא שהפינגווין לא יתקע בקרח.
• מוסיפים את הספרייט לשכבת הספרייט.
• צור סצנה חדשה מתוך שכבת הספרייט והפעל אותה.

def startGame (): figLayer = ScrollableLayer () fig = Sprite ('pingu.png') fig.position = (75, 100) figLayer.add (fig) # gameSc = Scene (figLayer) director.run (gameSc)

• הפעל את הקוד. אתה אמור לראות דמות פינגווין קטנה (או מה שציירת) על רקע שחור לאחר לחיצה התחל משחק.

שלב 9. תחלום על הנוף שלך

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

• צור סט אריחים.ערכת האריחים למשחק זה תהיה בסיסית מאוד: אריח אחד לקרח ואריח אחד לשמיים. אריח הקרח המשמש בדוגמה זו הוא מכאן, תחת CC-BY-SA 3.0.
• צור תמונה של ערכת אריחים. זוהי תמונה של כל האריחים, שצריכים להיות כולם באותו גודל (ערוך אותם אם אין) ויש להם את הגודל שאתה רוצה לראות במשחק, אחד ליד השני. שמור את התמונה שלך כ- icyTiles.png.

• צור את תיאור מערך האריחים. זה קובץ XML. קובץ ה- XML מכיל מידע על גודל האריחים בתמונת ערכת האריחים, באיזו תמונה להשתמש והיכן למצוא איזה אריח יש. צור קובץ XML בשם icyTiles.xml עם הקוד שלהלן:

שלב 10. הכינו מפת אריחים לנוף שלכם

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

• גלה כמה שורות ועמודות נחוצות. לשם כך, חלק את גודל המסך בגודל האריח הן אופקית (עמודות) והן אנכית (שורות). לעגל את המספר כלפי מעלה; אתה צריך פונקציה של מודול המתמטיקה לשם כך, אז הוסף מתקרת ייבוא מתמטית ליבוא בראש הקוד שלך.
• פתח קובץ לכתיבה. פעולה זו תמחק את כל התוכן הקודם של הקובץ, לכן בחר שם שעדיין אין קובץ בספרייה, כמו levelMap.xml.
• כתוב את תגי הפתיחה לתוך הקובץ.
• צור מפת אריחים על פי האלגוריתם. אתה משתמש בזה שבקוד למטה, או שאתה יכול להמציא אחד לבד. הקפד לייבא את הפונקציה randint מהמודול אקראי: הוא נדרש כדי שהקוד שלהלן יעבוד, וכל מה שתמצא כנראה יצטרך גם מספרים שלמים אקראיים. כמו כן, הקפד לשים אריחי שמיים ואריחי קרח בשכבות שונות: קרח מוצק, שמיים לא.
• כתוב את תגי הסגירה לתוך הקובץ וסגור את הקובץ.

def generateTilemap (): colAmount = תקרה (800 /16) * 3 # (רוחב מסך / גודל אריח) * 3 rowAmount = תקרה (600 /16) # גובה מסך / גודל אריח tileFile = open ("levelMap.xml", " w ") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) עבור i בטווח (0, colAmount): tileFile.write ('') makeHole = False if randint (0, 50) == 10 ו- i! = 0: # אל תאפשר חורים ב- spawnpoint makeHole = נכון עבור j בטווח (0, rowAmount): אם makeHole: tileFile.write ('\ n') אחר: אם j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight+5) אם iceHeight <0: # הגבל את האריחים מלהיות iceHeight = randint נמוך מדי (1, 5) if iceHeight> rowAmount: # הגבל אריחים מלהגיע לקרח גבוה מדי = Randint (int (rowAmount/2) -5, int (rowAmount/2) +5) tileFile.write ('\ n') tileFile.write ('\ n / n') עבור i בטווח (0, colAmount): tileFile.write ('') עבור j בטווח (0, rowAmount): tileFile.write ('\ n') tileFile.write ('\ n ') tileFile.write (' / n / n ') tileFile.close ()

שלב 11. הצג את מפת האריחים

ייבא הכל מ- cocos.tiles ולאחר מכן היכנס לשם כך לפונקציית startGame.

• בתחילת הפונקציה startGame, צור מפת אריחים באמצעות הפונקציה שהגדרת עבורה.
• צור מנהל גלילה חדש. בצע זאת ישירות מתחת לקו בו אתה מוסיף את הספרייט לשכבה שלו.
• צור שכבה חדשה המכילה את האריחים, שתטען ממפת האריחים levelMap.xml שהפונקציה generateTilemap שלך נוצרה.
• הוסף למנהל הגלילה את השכבה הלא מוצקה, את השכבה המוצקה ואת שכבת הספרייט, בדיוק בסדר הזה. אתה יכול להוסיף מיקום z אם אתה רוצה.
• במקום ליצור את הסצנה משכבת הספרייט, צור אותה ממנהל הגלילה.

• הפונקציה startGame שלך אמורה להיראות כך:

  def startGame (): createTilemap () # fig = Sprite ('pingu.png') fig.position = (8, 500) figLayer = ScrollableLayer () figLayer.add (fig) # tileLayer = load ('levelMap.xml') solidTiles = tileLayer ['solid'] nsoliTiles = tileLayer ['not_solid'] # scrMang = ScrollingManager () scrMang.add (nsoliTiles, z = -1) scrMang.add (solidTiles, z = 0) scrMang.add (figLayer, z = 1) # gameSc = Scene (scrMang) director.run (gameSc)
  

שלב 12. בדוק את הקוד שלך

עליך לבדוק את הקוד שלך לעתים קרובות כדי לוודא שהתכונות החדשות שיישמת אכן עובדות.

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

שלב 13. הוסף את הפקדים

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

• ייבא הכל מ- cocos.mapcolliders ומ- cocos.actions. ייבא גם מפתח מ- pyglet.window.

• "הכריז" על כמה משתנים גלובליים. משתנים גלובליים משותפים בין פונקציות. אינך יכול באמת להכריז על משתנים ב- Python, אך עליך לומר כי קיים משתנה גלובלי בקוד הראשי לפני השימוש בו. אתה יכול להקצות 0 כערך מכיוון שפונקציה תדאג להקצות את הערך הנכון מאוחר יותר. אז הוסף תחת ביטויי הייבוא:

  # "הכרזה" משתנים גלובליים מקלדת = 0 scrMang = 0
  

• התאם את פונקציית startGame שלך:

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

  def startGame (): מקלדת גלובלית, scrMang generatedTilemap () # fig = Sprite ('pingu.png') fig.position = (8, 250) figLayer = ScrollableLayer () figLayer.add (fig) # tileLayer = load ('levelMap.xml ') solidTiles = tileLayer [' solid '] nsoliTiles = tileLayer [' not_solid '] # keyboard = key. KeyStateHandler () director.window.push_handlers (מקלדת) # fig.do (PlatformerController ()) mapcollider = RectMapCollider (velocity_on_bump) = 'שקף') fig.collision_handler = make_collision_handler (mapcollider, solidTiles) # scrMang = ScrollingManager () scrMang.add (nsoliTiles, z = -1) scrMang.add (solidTiles, z = 0) scrMang.add (figLayer, z = 1) # gameSc = Scene (scrMang) director.run (gameSc)
  

• צור בקר פלטפורמות. זה מה שיזיז את הדמות בהתאם ללחיצות המקשים שלך.

  • הגדר את בקר הפלטפורמה כתת -סוג של פעולה.
  • הגדר את מהירות המהלך, את מהירות הקפיצה ואת כוח הכבידה.
  • הגדר את פונקציית ההתחלה. פונקציה זו נקראת פעם אחת, כאשר בקר הפלטפורמה מחובר לדמות. הוא צריך להגדיר את המהירות שלו ל 0 הן בכיוון x והן בכיוון y.
  • הגדר את פונקציית הצעד. זה יחזור על עצמו בזמן שהסצנה פועלת.
  • ספר לפונקציית הצעד להשתמש במקלדת וב- scrMang של המשתנים הגלובליים.
  • קבל ושנה את המהירות. שמור את המהירות x ואת y במשתנים נפרדים. הגדר את מהירות x ל- 1 או -1 (תלוי אם לחצו על המקש השמאלי או הימני) כפול מהירות ההליכה. הוסף את כוח הכבידה למהירות y. הכפל אותו עם השבתה כך שהוא עובד באותה הדרך במכשירים איטיים יותר. אם לוחצים על מקש הרווח והדמות עומדת על הקרקע, קפצו על ידי שינוי מהירות y למהירות הקפיצה.
  • חשב לאן הדמות צריכה לנוע. לאחר מכן תן למטפל ההתנגשות להתאים את המיקום הזה אם הוא בתוך אריח מוצק. לבסוף, העבר את הדמות למיקום המותאם החדש.
  • הגדר את המיקוד של מנהל הגלילה על הדמות. זה גורם למצלמה לנוע בצורה סבירה כאשר הדמות נעה.

  class Platform Controller (פעולה): מקלדת גלובלית, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (self): self.target.velocity = (0, 0) def step (עצמי, dt): מקלדת גלובלית, גלילה אם dt> 0.1: # אל תעשה דבר בזמן השבתה להחזרה גדולה vx, vy = self.target.velocity vx = (מקלדת [key. RIGHT] - מקלדת [key. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt אם self.on_ground ומקלדת [key. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect () new = last.copy () חדש.x += dx new.y += dy self.target.velocity = self.target.collision_handler (אחרון, חדש, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (*new.center)
  

שלב 14. בדוק את הקוד שלך

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

שלב 15. צור סוף למשחק

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

• בתוך בקר הפלטפורמה, לאחר הגדרת המיקוד, קבל את מיקום x ו- y של הדמות. אם מיקום y קטן מ- 0, התקשר לפונקציה finishGame () (תכתוב אותה מאוחר יותר) עם "Game Over" כארגומנט. אם מיקום x גדול מגודל המסך כפול 3 (הגדרת את זה כגודל רמה לפני כן).

  posX, posY = self.target.position אם posY <0: finishGame ("Game Over") החזרה אם posX> 800*3: # level size finishGame ("רמה הושלמה") החזרה
  

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

  class FinishMenu (תפריט): def _init _ (self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("נסה שוב", startGame)), (MenuItem ("צא", pyglet.app.exit))] self.create_menu (menuItems)
  

• הגדר את הפונקציה finishGame (). זה צריך לקחת טקסט כטיעון. זה אמור ליצור סצנה מרקע התפריט הראשי, FinishMenu עם טיעון הטקסט מועבר לתפריט זה. אז זה צריך להריץ את הסצנה הזו.

  def finishGame (טקסט): menuSc = Scene (MainMenuBgr ()) menuSc.add (FinishMenu (טקסט)) director.run (menuSc)
  

שלב 16. הוספת נקודות זכות

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

• צור קובץ CREDITS והזן שם את כל הקרדיטים שלך, כך:

  פינגווין: קלווין שיידינג, תחת בלוק CC0 CC0: Michał Banas digit1024 ב- opengameart.org תחת CC-BY-SA 3.0
  

• חזור לקוד ה- Python שלך וייבא תווית מ- cocos.text.

• הגדר תת -סוג קרדיטים של שכבה. בפונקציית _init_ שלו, קרא את קובץ ה- CREDITS ועשה תווית טקסט במיקום הנכון מתוך כל שורה בו.

  Credits class (Layer): def _init _ (self): super (Credits, self)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n ") עבור i בטווח (0, len (creds)): credLabel = Label (creds , font_size = 32, anchor_x =" left ", anchor_y =" top ") credLabel.position = 25, 500- (i +1)*40 self.add (credLabel)
  

• עבור למחלקת התפריט הראשי שלך והוסף פריט בתפריט שכותרתו "זיכויים" המכנה את הפונקציה showCredits בלחיצה.

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

  class BackToMainMenuButton (תפריט): def _init _ (self): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem ("Back"), showMainMu). תפריט create_menu (תפריט תפריט)
  

• הגדר את הפונקציה showCredits. היא אמורה ליצור סצנה משכבת MainMenuBgr ושכבת Credits ולהריץ את הסצנה הזו.

  def showCredits (): credSc = Scene (MainMenuBgr ()) credSc.add (Credits ()) credSc.add (BackToMainMenuButton ()) director.run (credSc)
  

שלב 17. בדוק את הקוד שלך

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

מיבוא cocos.director * מיבוא cocos.menu * מיבוא cocos.scene * מיבוא cocos.layer * מיבוא cocos.spite * מיבוא cocos.hurt * מ- cocos.mabcolliders יבוא * מייבוא cocos.actions יבוא * מקוקוס ייבוא טקסט תווית ייבוא pyglet.app מ pyglet.window מפתח ייבוא מתקרת ייבוא מתמטית מ randint יבוא אקראי # "הכרזה" משתנים גלובליים מקלדת = 0 scrMang = 0 class MainMenuBgr (ColorLayer): def _init _ (עצמי): super (MainMenuBgr, עצמי)._ init _ (0, 200, 255, 255) תפריט MainMenu (תפריט): def _init _ (self): super (MainMenu, self)._ init _ ("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("התחל משחק", startGame)), (MenuItem ("Credits", showCredits)), (MenuItem ("צא", pyglet.app.exit))] self.create_menu (menuItems) Credits (Layer): def _init _ (self): super (Credits, self)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n") עבור i בטווח (0, len (credd)): credLabel = Label (אישורים , font_size = 32, anchor_x = "left", anchor_y = "top") credLabel.position = 25, 500- (i+1)*40 self.add (credLabel) class BackToMainMenuButton (תפריט): def _init _ (עצמי): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem ("Back", showMainMenu)] self.create_menu (menuItems) class FinishMenin (תפריט): def_ self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("נסה שוב", startGame)), (MenuItem ("צא", פיגלון. app.exit))] self.create_menu (menuItems) PlatformerController בכיתה (פעולה): מקלדת גלובלית, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (self): self.target.velocity = (0, 0) שלב def (עצמי, dt): מקלדת גלובלית, גלילה אם dt> 0.1: # אל תעשה דבר בזמן השבתה החזרה גדולה מדי vx, vy = self.target.velocity vx = (מקלדת [key. RIGHT] - מקלדת [key. LEFT]) * self. MOVE_SPEED vy += self. GRAVITY * dt if self.on _ קרקע ומקלדת [key. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect () new = last.copy () new.x += dx new.y + = dy self.target.velocity = self.target.collision_handler (אחרון, חדש, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (* new.center) posX, posY = self.target.position אם posY <0: finishGame ("Game Over") החזר אם posX> 800*3: # level size finishGame ("רמה הושלמה") החזר def finishGame (טקסט): menuSc = Scene (MainMenuBgr ()) menuSc.add (FinishMenu (טקסט)) director.run (menuSc) def showCredits (): credSc = Scene (MainMenuBgr ()) credSc.add (Credits ()) credSc.add (BackToMainMenuButton ()) director.run (credSc) def generatedTilemap (): colAmount = תקרה (800 /16) * 3 # (רוחב מסך / גודל אריח) * 3 rowAmount = תקרה (600 /16) # גובה מסך / גודל אריח אריח = פתוח ("levelMap.xml", "w") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) עבור i בטווח (0, colAmount): tileFile.write ('') makeHole = שקר אם ראנד int (0, 50) == 10 ו- i! = 0: # אל תאפשר חורים ב- spawnpoint makeHole = נכון עבור j בטווח (0, rowAmount): if makeHole: tileFile.write ('\ n') אחר: אם j <= iceHeight: tileFile.write ('\ n') אחר: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight+5) אם iceHeight <0: # הגבל את האריח גם מלעבור low iceHeight = randint (1, 5) if iceHeight> rowAmount: # הגבל אריחים מלהגיע גבוה מדי iceHeight = randint (int (rowAmount/2) -5, int (rowAmount/2) +5) tileFile.write ('\ n ') tileFile.write (' / n / n ') עבור i בטווח (0, colAmount): tileFile.write (' ') עבור j בטווח (0, rowAmount): tileFile.write (' / n ') tileFile.write ('\ n') tileFile.write ('\ n / n') tileFile.close () def startGame (): מקלדת גלובלית, scrMang generatedTilemap () # fig = Sprite ('pingu.png') איור מיקום = (8, 250) figLayer = ScrollableLayer () figLayer.add (fig) # tileLayer = load ('levelMap.xml') solidTiles = tileLayer ['solid'] nsoliTiles = tileLayer ['not_solid'] # keyboard = key. KeyStateHandler () director.window.push_handlers (keybo ard) # fig.do (PlatformerController ()) mapcollider = RectMapCollider (velocity_on_bump = 'slide') fig.collision_handler = make_collision_handler (mapcollider, solidTiles) # scrMang = ScrollingManager () scrMang.add (nsoliTiles, z = -1) הוסף (solidTiles, z = 0) scrMang.add (figLayer, z = 1) # gameSc = Scene (scrMang) director.run (gameSc) def showMainMenu (): menuSc = Scene (MainMenuBgr ()) menuSc.add (MainMenu ()) director.run (menuSc) window = director.init (caption = "IcyPlat - פלטפורמה פשוטה", resizable = True) showMainMenu ()

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

שלב 18. סיים

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

חלק 3 מתוך 3: הוצאת משחק

שלב 1. רשום את התלות

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

שלב 2. ודא שיש לך הרשאה להשתמש בכל המדיה

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

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

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

שלב 3. החליטו על התנאים שבהם אתם רוצים לפרסם את המשחק שלכם

האם תמכור את המשחק שלך? האם אתה רוצה לאפשר לאחרים להשתמש בתמונות וברעיונות שלך? בעוד שאתה צריך להיות זהיר לגבי המדיה שבה אתה משתמש בפרויקט שלך, בדרך כלל אתה יכול להחליט כיצד אתה רוצה לאפשר לאחרים להשתמש במשחק שלך. אתה יכול להשתמש ברישיון Creative Commons CC0 כדי לשחרר את המשחק ברשות הרבים.. כדי לאפשר הפצה ושינוי בתנאים מסוימים תוך שמירה על זכויות מסוימות, נסה את הרישיון הציבורי הכללי של Gnu (GPL) או את רישיון הפצת התוכנה של ברקלי (BSD). או שתוכל להפוך את התוכנה שלך לקניינית, כלומר לאף אחד אסור להפיץ או לשנות אותה ללא רשותך.

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

שלב 4. החליט כיצד ברצונך לפרסם את המשחק שלך

לכל שיטה יש כמה יתרונות וחסרונות, אז אתה צריך להחליט בעצמך.

• פרסום זה באתר:

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

• הכנת חבילה למנהל חבילות:

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

שלב 5. תשומת לב ישירה לתוכנית שלך

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

טיפים

• היו סבלניים ומוכנים ללמוד. תכנות יכול לפעמים להיות מתסכל!
• אם אתה תוהה כיצד משהו נעשה במשחק אחר, והמשחק הוא קוד פתוח, אתה יכול להסתכל על קוד המקור שלו.
• כשאתה מחפש מדיה, נסה למצוא תוכן הנמצא ברשות הרבים. חפש תמונות ומוזיקה של "Creative Commons" או "Public Domain" והשתמש באתרים כמו https://opengameart.org או
• אין להעתיק נתחי קוד גדולים מבלי לבדוק את הרישיון. לרוב זה אסור, ואם לא, בדרך כלל דורש ייחוס.
• אל תעשה ספאם או פרסם במקומות לא מתאימים בעת קידום המשחק שלך. סביר להניח שזה יחסום אותך מהדף, הוא פשוט מעצבן ויפגע במוניטין שלך.