אני לא רוצה עכשייו פירוש

אני רוצה קודם כל לדעת אם תוכלו לעזור לי

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

וכדור שנע ביניהם

משהו סטנדרטי לצורך לימוד

עכשיו אני אישית בראש עיצבתי את התוכנית בצורה הבאה

1. יצירת לוח המשחק.

2. יצירת 2 הקווים + יכולת תנועה עם handling על העכבר שכאשר הוא מזהה תנועה למעלה הוא משנה את המיקום של תמונה א' לדוגמא יותר כלפי מעלה כנ"ל ההפך

3. יצירת כדור משחק

4. יצירת תנועה לכדור משחק

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

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

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

אם כן האם תוכלו לעזור לי

אני בתכלס רוצה לבנות את זה ב c++

אבל אני מתכנת בסביבת לינוקס בעזרת wxwidgets

אז אני מעדיף שתעזרו עם c# שהיא יותר נפוצה פה

ואני כבר יעשה לזה הסבה לשפה שלי

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

אבל בכל מקרה, מה שרשמת זה לא תכנון, זה תאור של "מוצר" ומה הוא צריך לבצע.

תתחיל בחלוקה למחלקות, ואיפיון של כל מחלקה ( DATA MEMBER ופונקציות ).

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

אני צריך לדעת האם התכנון שמניתי נכון

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

אני כל תוכנית שאני בונה אני עושה בשלבים

דבר שני

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

מה שרשמת זה לא תכנון, זה תאור של "מוצר" ומה הוא צריך לבצע.

תתחיל בחלוקה למחלקות, ואיפיון של כל מחלקה ( DATA MEMBER ופונקציות ).

גם משחק פשוט כמו זה אפשר למדל כזה מכאן ועד הודעה חדשה, אבל הדרך העדיפה (לטעמי) היא שרוב הלוגיקה יהיה באובייקט "משחק", ושהכדור וה - paddles יהיו אובייקטים 'טיפשים' שאובייקט המשחק הוא זה שמזיז אותם.

אם אתה רוצה לשכלל קצת את השליטה (לאפשר AI, שני שחקנים, וכו') אתה יכול לכתוב class לצורך controller, שמתחבר לאובייקט שאפשר לשחק:

בתחילת כל cycle של המשחק ה- controllers קוראים/מחשבים את הקלט שלהם, והקלט שלהם מועבר לאובייקט שאליו הוא מחובר.

בומרנג

העיניין

שאני לא יודע איך לעשות את זה

אני צריך הכוונה

אני צריך מדריך

הסתכלתי במקורות של משחקים שנבנו

לא היה בדיוק מובן

אני צריך לפחות הכוונה

תבנה אובייקט כך וכך שיכיל את......

אני מוכן לקבל עזרה באי סי קיו אפילו בפלאפון

לעשות גרפיקה אתה יוגע?

כי זה חלק דיי נכבד.

בכ"א, לדעתי אתה צריך ליצור את האובייקטים בצורה כזו:

אובייקט "לוח" שהוא בעצמם המנוע של המשחק.

אובייקט "כדור", שיחזיק בתוכו רק את המיקום של הכדור (נ"צ), ומטודות לשינוי המיקום

אובייקט "מטקה", שיחזיק בתוכו את המיקום של המטקה, ומתודה להזזה למעלה/מטה.

אובייט "שחקן" שיחזיק את המטקה ואת הניקוד כאיברים.

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

אגב, אם אתה יודע לעשות threading, אז כדאי לך שהמטודת תזוזה של הכדור תרוץ בת'רד, ויהיו לו אירועים כאשר הוא פוגש בדברים, ואז תוכל פחות לדאוג לתזוזת הכדור במגרש.

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

הנה טיפה מבוא כללי לתכנות משחקים (עוד לפני שמדברים על שפה או סביבת עבודה):

במודל המקובל של משחק מחשב, החלק העיקרי הוא ה- main game loop, שזו לולאה שחוזרת על עצמה ומורכבת מהחלקים הבאים:

1. קלט (למשל - לקרוא מהמקלדת אם המקש שאומר 'למעלה' לחוץ, ואם כן - להעביר הלאה את הפקודה 'למעלה')

2. עדכון מידע (למשל - לראות שהתקבלה הפקודה 'למעלה' ולעדכן את המיקום של העצם שאמור לזוז)

3. ציור למסך

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

אם אתה עובד תחת חלונות מאיזשהו סוג אז בעצם כבר יש לך את ה- event loop/window procedure שמתפקדת כ- game loop, ואתה רק צריך לגרום ל- event כל פרק זמן קבוע.

חחחחחחחחח

לא הבנתם נראה לי נכון

אני מדבר על משהו סגנון כזה

http://www.jesperjuul.net/gfx/projects/PingPong.gif

מה שבומרנג אמר זה בעצם מה שחשבתי

תיהיה כזאת צורה

וזה לא קשה מדיי

ישנו לוח

וישנו לופ שכל הזמן מחכה לפקודה של המקלדת

ברגע שהוא מקבל keyup הוא שולח פקודה לשנות את המיקום של המטקה למעלה

ברגע שיש keydown ההפך

את המטקה אפשר לחלק ללפחות 5 חלקים שכל חלק שהוא יפגע ישנה את הסטייה של הכדור ותחזיר אותו לצד השני עם הסטייה

תכלס זה לא קשה

זה נשמע קל

אגב

אני מתכנת בסביבת לינוקס

עם sdl

עריכה:

חשבתי גם על צורה שאיך הכדור ידע אם הוא פגע במטקה

תיהיה פונקציה שתחשב כל הזמן את המיקום של המטקה ותשלח אותה ל2 משתנים x ו y לדוגמא

ברגע שהכדור ינוע כל רגע הוא ישלח פוקדה עם המיקום

ברגע שהוא יגיע למיקום של המטקה

הוא פשוט יחזור חזרה

תיהיה גם פונקציה שבעצם תעשה drawimg ובכל פעם שיתקבל keyup לדוגמא היא תשנה את המשתנה x ותוסיף לו לדוגמא +5 ותשלח לפונקציה drawimg ותמחק את התמונה הקודמת ותעלה את החדשה עם המיקום החדש

אלא אם כן יש שיטה לשנות מיקום של תמונה אוטומטי

כמעט.

ה- loop לא מחכה לפקודה.

הכדור הרי צריך כל הזמן לעדכן את המיקום שלו.

זהו שכן

אז צריך פה גם multithreading

שתוך כדי שלולאה שמריצה את הכדור מחכה לתגובה ושינוי בזוית ההנעה

גם יש event handling שמחכה לתגובה מהמקלדת

נכון?

ממש ממש לא.

בשלב הזה זה רק ייסבך אותך עם סינכרון בין ה- threads ו- race conditions ביניהם.

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

אז זה יותר פשוט משחשבתי

כל העניין זה לולאה שמריצה את הכדור ואת התגובות של הכדור

ושתי events למקלדת שיזיזו את המטקות

סך הכול הלולאה היא לכדור

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

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

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

רק בסוף תשב ותתכנת.

דוגמא לאובייקטים והמתודות שלהן:

שחקן

-----

העלה ניקוד

הזז לוח שחקן

קבל מיקום לוח שחקן

לוח

----

הזז ימינה/שמאלה

קבל מיקום לוח

צייר לוח

כדור

----

הזז כדור

קבל כדור

צייר כדור

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