כיצד לתכנת משחקים ב- C. הדרכה ראשונה

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

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

אתה מתחיל להיות בעל מערכת 0 ואילו מערכת האויב שלך משלך 9. שמונת המערכות הנותרות (1-8) מתחילות כולם ניטרליות. כל המערכות מתחילות בריבוע של 5 parsec x 5 parsec כך ששום מערכת איננה מרוחקת יותר מ- 6 parsec זה מזה. שתי הנקודות הרחוקות ביותר הן (0,0) ו- (4,4). לפי משפט פיתגורס, המרחק הרחוק ביותר משתי מערכות הוא השורש הריבועי ((4)² + (4)²) שהוא השורש המרובע של 32 שהוא בערך 5.657.

שימו לב, זו אינה הגרסה הסופית ותתוקן. שינוי אחרון: 21 באוגוסט 2011.

המשחק מבוסס על תור וכל סיבוב שאתה נותן פקודות להעביר כל מספר ציי מכל מערכת שיש לך למערכת אחרת. אם יש לך יותר ממערכת אחת אתה יכול להזמין ציי רכב לעבור מכל המערכות שלך למערכת היעד. זה נעשה באופן פרוטה מעוגל, כך שאם יש לך שלוש מערכות (1,2,3) עם 20, 10 ו -5 ציי רכב ואתה מזמין 10 ציים לעבור למערכת 4 ואז 6 יעברו ממערכת 1, 3 ממערכת 2 ו -1 ממערכת 3. כל צי מעביר 1 פרסק לסיבוב.

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

onesec = שעון () + (5 * CLOCKS_PER_SEC);

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

• נסה CC386
• או Visual C ++ אקספרס 2010

המאמר CC386 מנחה אותך ביצירת פרויקט. אם מתקינים את המהדר ההוא, כל שעליך לעשות הוא לטעון את תוכנית Hello World כמתואר, העתק והדבק את קוד המקור מעל הדוגמה, שמור אותו ואז לחץ על F7 כדי להרכיב אותו ולהריץ אותו. כמו כן המאמר Visual C ++ 2010 יוצר תוכנית עולם שלום. החלף אותו ולחץ על F7 כדי לבנות אימפריות סטאר., F5 כדי להריץ אותו.

בעמוד הבא הפיכת אימפריות הכוכבים לעבודה

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

• מערכת מקור (1-10).
• מערכת יעד (1-10)
• כמה ספינות (1-רבות)
• פונה להגיע
• מי זה הצי? 0 = שחקן, 9 = אויב

אנו משתמשים במבנה ב- C כדי לקיים זאת:

מבנה הוא אוסף של נתונים, במקרה זה 5 מספרים שאנו מתפעלים כאחד. לכל מספר יש שם, למשל מ- system, tosystem. שמות אלה הם שמות משתנים ב- C ויכולים להיות תחתונים כמו_זה אך לא רווחים. ב- C המספרים הם מספר שלם. מספרים שלמים כמו 2 או 7 אלה נקראים אינץ ', או מספרים עם חלקים עשרוניים כמו 2.5 או 7.3333 ואלה נקראים צפים. בכל אימפריות הכוכבים אנו משתמשים רק בצפות פעם אחת. בגוש קוד המחושב את המרחק בין שני מקומות. כל מספר אחר הוא אמצע.

צי צי הוא השם למבנה נתונים המכיל חמישה משתני int. עכשיו זה עבור צי אחד. אנחנו לא יודעים כמה ציי רכב נצטרך להחזיק ולכן נקצה מקום נדיב ל 100 באמצעות מערך. חשוב על מבנה כמו שולחן ארוחת ערב עם מקום לחמישה אנשים (אינץ '). מערך דומה לשורה ארוכה של שולחנות ארוחת ערב. 100 שולחנות פירושו שהוא יכול להכיל 100X5 אנשים.

אם היינו מגישים את 100 שולחנות הארוחה האלה, היינו צריכים לדעת איזה שולחן הוא ואנחנו עושים זאת על ידי מספור. ב- C אנו תמיד מונים אלמנטים של מערכים המתחילים ב- 0. שולחן הארוחה הראשון (צי) הוא מספר 0, הבא הוא 1 והאחרון הוא 99. אני תמיד זוכר שזה כמה שולחנות ארוחת הערב השולחן הזה מההתחלה? הראשון בתחילתו הוא גם 0.

כך אנו מכריזים על ציי הרכב (כלומר שולחנות הארוחה שלנו).

קרא את זה משמאל לימין. צי מבנים מתייחס למבנה שלנו להחזקת צי אחד. ציי הצבים הוא השם שאנו נותנים לכל ציי הצי ו [100] אומר לנו שיש 100 x צי סטרוקטורה במשתנה הציים. כל אחד מהאינטרנט תופס 4 מיקומים בזיכרון (נקרא בתים) כך שצי אחד תופס 20 בתים ו- 100 ציי ים הוא 2000 בתים. תמיד כדאי לדעת כמה זיכרון התוכנית שלנו צריכה להחזיק בנתונים שלה.

בצי ה- struct כל אחד מהאינטס מחזיק מספר שלם. מספר זה מאוחסן ב -4 בתים והטווח של זה הוא בין -2,147,483,647 ל 2,147,483,648. לרוב נשתמש בערכים קטנים יותר. ישנן עשר מערכות כך שגם מערכת וגם מערכת מערכת יחזיקו בערכים 0 עד 9.

בעמוד הבא: מערכות ומספרים אקראיים

כל אחת מהמערכות הנייטרליות (1-8) מתחילה עם 15 אוניות (מספר שנבחרתי מהאוויר!) מלכתחילה ולשתי האחרות (שלך: מערכת 0 ויריב המחשב שלך במערכת 9) יש 50 ספינות כל אחת. בכל סיבוב גדל מספר האוניות במערכת בכ -10% מעוגל. אז אחרי סיבוב אחד אם לא תזיז אותם, 50 שלך יהפכו ל 55 ולכל אחת מהמערכות הניטרליות יהיו 16 (15 + 1.5 מעוגל). שים לב שצי שעובר למערכת אחרת לא גדל במספרים.

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

בהתחלה עלינו לייצר את כל המערכות ולהעלות אותן על המפה עם מקסימום מערכת אחת בכל מיקום, מכיוון שיש 25 מיקומים ברשת 5 x 5 שלנו, יהיו לנו עשר מערכות ו -15 ריקות מיקומים. אנו מייצרים אותם באמצעות הפונקציה GenMapSystems () בה אנו מסתכלים בעמוד הבא.

מערכת מאוחסנת במבנה, עם 4 השדות הבאים שהם כולם אינטש.

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

כל המשחקים זקוקים למספרים אקראיים. ל- C יש פונקציה מובנית של ראנד () המחזירה אינטראקציה אקראית. אנו יכולים להכריח את זה לטווח על ידי העברת המספר המקסימלי פנימה ושימוש במפעיל%. (מודולוס). זה כמו שעון אריתמטי, אלא שבמקום 12 או 24 אנו עוברים מספר int שנקרא מקסימום.

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

• מעניין מה זה מהדר? לקרוא מה זה מהדר? (מאמר)

פונקציה דומה לפונקציה מתמטית כמו Sin (x). ישנם שלושה חלקים לפונקציה זו:

ה- int אומר איזה סוג מספר הוא מחזיר (בדרך כלל int או float). אקראי הוא שם הפונקציה ו (int max) אומר שאנחנו מעבירים מספר int. אנו עשויים להשתמש בזה כך:

השורה:

בעמוד הבא: יצירת מפת התחלה אקראית

קוד זה להלן מייצר את מפת ההתחלה. זהו זה שמוצג לעיל.

יצירת מערכות היא עניין של הוספת השחקן ומערכות היריב (ב 0,0) ו- (4,4) ואז הוספת אקראית 8 מערכות ב 23 המיקומים הריקים הנותרים.

הקוד משתמש בשלושה משתני int מוגדרים על ידי הקו

משתנה הוא מיקום בזיכרון שמחזיק בערך int. המשתנים x ו- y מחזיקים את קואורדינטות המערכות ויחזיקו ערך בטווח 0-4. המשתנה i משמש לספירה בלולאות.

כדי להציב את 8 המערכות האקראיות ברשת 5x5 עלינו לדעת אם למיקום יש מערכת כבר ולמנוע הצבת אחת אחרת באותו מיקום. לשם כך אנו משתמשים במערך פשוט דו-ממדי של דמויות. Char סוג הוא סוג אחר של משתנה ב- C ומחזיק תו בודד כמו 'B' או 'x'.

הסוג הבסיסי של המשתנים ב- C הם int (מספרים שלמים כמו 46), char (תו בודד כמו 'A') וציפה (להחזקת מספרים עם נקודה צפה כמו 3.567). מערכים [] מיועדים להחזקת רשימות של אותו אלמנט. אז char [5] [5] מגדיר רשימת רשימות; מערך דו-ממדי של תווים. חשבו על זה כמו 25 חתיכות Scrabble מסודרות ברשת 5 על 5.

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

• x = 0; זהו חלק האתחול.
• איקס
• x ++. זהו חלק השינוי. זה מוסיף 1 ל- x.

אז (עבור (x = 0; x

בתוך ה- for (x loop הוא לולאה ל- y שעושה את אותו הדבר עבור y. לולאת y זו מתרחשת עבור כל ערך של X. כאשר X הוא 0, Y יעבור בין 0 ל -4, כאשר X הוא 1, Y יעבור לולאה וכן הלאה. המשמעות היא שכל אחד מ -25 המיקומים במערך הפריסה מאתחל למרחב.

לאחר לולאת for הפונקציה InitSystem נקראת עם חמישה פרמטרים int. יש להגדיר פונקציה לפני שהיא נקראת או שהמהדר לא יודע כמה פרמטרים עליו להיות. ל- InitSystem חמשת הפרמטרים הללו.

בעמוד הבא: יצירת מפת התחלה אקראית ממשיכה ...

אלה הפרמטרים ל- InitSystem.

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

אז הקו InitSystem (0,0,0,50,0) מאתחל מערכת 0 במיקומים x = -0, y = 0 עם 50 ספינות לבעלים 0.

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

יש שני לולאות מקוננות בקוד זה. הלולאה החיצונית היא אמירה עבור המונה את המשתנה i מערך התחלתי של 1 לערך סופי של 8. אנו נשתמש ב- i כדי להתייחס למערכת. זכור שכבר התחלנו במערכת 0 ו- 9 במערכת, אז כעת אנו מאתחלים מערכות 1-8.

כל מה שעושים {עד זמן (פריסה [x] [y] הוא הלולאה השנייה. התחביר הוא לעשות {משהו} בזמן (התנאי נכון); אז אנו מקצים ערכים אקראיים ל- x ו- y, כל ערך בטווח 0-4. אקראי (5) מחזיר ערך בטווח 1 עד 5, חיסור 1 מקבל את הטווח 0-4.

אנחנו לא רוצים להציב שתי מערכות באותן קואורדינטות כך שהלולאה הזו מחפשת מיקום אקראי שיש בו רווח. אם יש מערכת שם, הפריסה [x] [y] לא תהיה רווח. כשאנחנו קוראים ל- InitSystem זה שם שם אחר. BTW! = פירושו לא שווה ל- == פירושו שווה ל.

כאשר הקוד מגיע ל- InitSystem לאחר זמן מה (פריסה [x] [y]! = ''), X ו- y בהחלט מתייחסים למקום בפריסה שיש בו רווח. כך נוכל להתקשר ל- InitSystem ואז לעבור סביב הלולאה for כדי למצוא מיקום אקראי למערכת הבאה עד שכל 8 המערכות יונחו.

השיחה הראשונה ל- InitSystem מגדירה את מערכת 0 במיקום 0,0 (השמאלי העליון של הרשת) עם 50 ציי וניצחה על ידי. השיחה השנייה מאתחלת את מערכת 9 במיקום 4,4 (מימין למטה) עם 50 ציי והיא בבעלות שחקן 1. נבחן מקרוב את מה שבאמת עושה InitSystem במדריך הבא.

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

• # הגדר WIDTH 80
• # הגדר את HEIGHT 50
• # הגדר MAXLEN 4
• # הגדר MAXFLEETS 100
• #define MAXSYSTEMS 10
• # הגדר FIGHTMARKER 999

במדריך זה סקרנו משתנים והשימוש ב- int, char ו- struct כדי לקבץ אותם בתוספת מערך ליצירת רשימה. ואז לולאות פשוטות באמצעות for and do. אם אתה בוחן את קוד המקור, אותם מבנים נראים פעם אחר פעם.

• עבור (i = 0; i
• עבור (i = 0; i

הדרכה תסתכל על ההיבטים של C המוזכרים במדריך זה.