Ունե՞ք համակարգչային խաղի գաղափար և ցանկանում եք այն իրական դարձնել: Կամ երբևէ մտածե՞լ եք, թե ինչպես են գրվում համակարգչային խաղերը: Այս wikiHow- ը սովորեցնում է ձեզ, թե ինչպես գրել երեք հիմնական համակարգչային խաղ Python- ում: Ձեր առաջին խաղը մշակելու համար ձեզ հարկավոր է հիմնական հասկացություն Python- ի և ծրագրավորման ընդհանուր հասկացությունների վերաբերյալ:
Քայլեր
Մաս 1-ը 3-ից. Տեքստային խաղ պատրաստելը
Քայլ 1. Ընտրեք ծրագրավորման լեզու:
Բոլոր ծրագրավորման լեզուները տարբեր են, այնպես որ դուք պետք է որոշեք, թե որ լեզվով գրել ձեր խաղը: Majorրագրավորման յուրաքանչյուր հիմնական լեզու աջակցում է տեքստի մուտքագրմանը, տեքստի ելքին և եթե-կոնստրուկցիաներին (հիմնականը, ինչ ձեզ հարկավոր է պարզ տեքստի վրա հիմնված խաղի համար), այնպես որ ուսումնասիրեք ընտրանքները և որոշեք, թե որն է ձեզ առավել հարմարավետ և նվիրված սովորելուն: Ահա որոշ գործոններ, որոնք պետք է հաշվի առնել.
-
Ո՞ր լեզուն է հիմնականում օգտագործվում:
Որոշ ծրագրավորման լեզուներ, ինչպես JavaScript- ը, նախատեսված են համացանցի համար օգտագործելու համար, իսկ մյուսները, ինչպես Python- ը, C- ն կամ C ++ -ը, նախատեսված են համակարգչային ծրագրեր գործարկելու համար: Ձեր խաղի համար նպատակ դրեք ավելի լայն օգտագործման լեզու, ինչպիսիք են Python, C, C ++ կամ JavaScript.
-
Որքա՞ն դժվար է սովորելը:
Թեև ծրագիր գրելը պետք է բավականին հեշտ լինի ցանկացած սովորական ծրագրավորման լեզվով որոշակի պրակտիկայից հետո (այսինքն ՝ ոչ թե այնպիսին, ինչպիսին հատուկ ստեղծված է շփոթեցուցիչ, ինչպես Մոլբոլգեն), սակայն ոմանք ավելի բարեկամական են սկսնակների համար, քան մյուսները: Java- ն և C- ն, օրինակ, կպահանջեն ձեզ հասկանալ ծրագրավորման ավելի խորը հասկացություններ, քան Python- ի նման մի բան, որը հայտնի է իր ավելի մատչելի և ուղիղ շարահյուսությամբ:
-
Որտեղ կարող եմ օգտագործել այն:
Դուք հավանաբար ցանկանում եք, որ տարբեր համակարգերի մարդիկ, ինչպիսիք են Linux- ը, Mac- ը կամ Windows- ը, բոլորը կարողանան խաղալ ձեր խաղը: Այսպիսով, դուք չպետք է օգտագործեք մի լեզու, որն աջակցվում է միայն մի քանի համակարգերում, ինչպես Visual Basic- ը, որը աջակցվում է միայն Windows- ում:
Այս հոդվածը կօգտագործի Python- ը տեքստային խաղի օրինակների համար, բայց կարող եք փնտրել, թե ինչպես են հասկացություններն արվում ծրագրավորման ցանկացած այլ լեզվով:
Քայլ 2. Պատրաստեք ձեր համակարգիչը:
Ձեզ անհրաժեշտ երկու հիմնական բաղադրիչներն են ՝ տեքստային խմբագիր, որում կգրեք ձեր ծածկագիրը և կազմող, որը կօգտագործեք այն խաղի վերածելու համար: Եթե ցանկանում եք հետևել այս հոդվածի օրինակին, ապա պետք է տեղադրեք Python և սովորեք, թե ինչպես գործարկել ծրագրեր: Եթե ցանկանում եք, կարող եք ստեղծել IDE (ինտեգրված աշխատասեղանի միջավայր), որը համատեղում է խմբագրումը, կազմումը և կարգաբերումը մեկ ծրագրի մեջ: Python- ի IDE- ն կոչվում է IDLE: Բայց դուք կարող եք պարզապես օգտագործել ցանկացած տեքստային խմբագիր, որն ապահովում է պարզ տեքստ, օրինակ ՝ Windows- ի Notepad, macOS- ի համար TextEdit կամ Linux- ի համար Vim:
Քայլ 3. Գրեք ինչ -որ ծածկագիր ՝ խաղացողին ողջունելու համար:
Խաղացողը կցանկանա իմանալ, թե ինչ է կատարվում և ինչ պետք է անի, այնպես որ դուք պետք է մի քանի տեքստ տպեք նրանց համար:
-
Դա արվում է Python- ում print () գործառույթով: Փորձելու համար բացեք.py ընդլայնմամբ նոր ֆայլ, մուտքագրեք դրա մեջ հետևյալ կոդը, պահպանեք և գործարկեք այն.
տպել («Բարի գալուստ թվերի կռահման խաղ») տպել («Մուտքագրեք ամբողջ թիվ 1 -ից 1000 -ի միջև.»)
Քայլ 4. Ստեղծեք պատահական թիվ:
Եկեք տեքստային խաղ պատրաստենք, որը խնդրում է խաղացողին կռահել ճիշտ թիվը: Առաջին բանը, որ մենք պետք է անենք, խաղի սկզբում պատահական թիվ ստեղծելն է, որպեսզի խաղացողը միշտ չգուշակի նույն թիվը: Քանի որ համարը կմնա նույնը ամբողջ ծրագրի ընթացքում, դուք կցանկանաք պատահական թիվը պահել փոփոխականի մեջ:
- Python- ը չունի ներկառուցված պատահական համարի գործառույթ, բայց ունի ստանդարտ գրադարան (դա նշանակում է, որ օգտագործողը ստիպված չի լինի լրացուցիչ որևէ բան տեղադրել), որն ունի: Այսպիսով, գնացեք ձեր ծածկագրի սկիզբը (նախքան print () գործառույթները) և մուտքագրեք տողի պատահական մուտքագրում:
-
Օգտագործեք պատահական գործառույթը: Այն կոչվում է randint (), գտնվում է ձեր ներմուծած պատահական գրադարանում և վերցնում է համարի նվազագույն և առավելագույն արժեքը, որը կարող է ունենալ որպես փաստարկ: Այսպիսով, վերադարձեք ձեր ծածկագրի վերջը և մուտքագրեք հետևյալ տողը.
rightNum = random.randint (0, 1000)
Քայլ 5. Ստացեք մուտքագրում նվագարկիչից:
Խաղի ընթացքում խաղացողը ցանկանում է ինչ -որ բան անել կամ ինչ -որ բանի հետ շփվել: Տեքստի վրա հիմնված խաղում դա հնարավոր է տեքստ մուտքագրելով: Այժմ, երբ մենք ունենք պատահական թիվ, մեր հաջորդ տողերը պետք է խնդրեն խաղացողին մուտքագրել իրենց լավագույն գուշակությունը:
-
Քանի որ ձեր մուտքագրած կոդը տպում է նվագարկիչին համար մուտքագրելու հրահանգը, այն պետք է կարդա նաև նրանց մուտքագրած թիվը: Դա արվում է Python 3 -ում մուտքագրված (), իսկ Python 2 -ում raw_input () միջոցով: Պետք է գրել Python 3 -ում, քանի որ Python 2 -ը շուտով կդառնա հնացած: Ավելացրեք հետևյալ տողը ձեր ծածկագրին ՝ խաղացողի մուտքագրումը համար կոչվող փոփոխականում պահելու համար.
userNum = մուտքագրում ()
Քայլ 6. Նվագարկիչի մուտքագրումը դարձրեք օգտագործելի տվյալների տիպ:
Խաղացողը մուտքագրեց համար-հիմա ինչ?
-
Խաղացողի մուտքագրումը համար դարձրեք: Այժմ սա կարող է շփոթեցուցիչ թվալ, քանի որ նրանք պարզապես մուտքագրել են համար: Բայց կա մի լավ պատճառ. Python- ը ենթադրում է, որ ամբողջ մուտքագրումը տեքստ է կամ «տող», ինչպես դա կոչվում է ծրագրավորման մեջ: Այս տեքստը պարունակում է այն համարը, որը ցանկանում եք ստանալ: Python- ն ունի գործառույթ, որը փոխակերպում է միայն մի շարք պարունակող տողը ներսի թվին: Տիպ:
userNum = int (userNum)
Քայլ 7. Համեմատեք խաղացողի համարը ճիշտ համարին:
Երբ խաղացողը մուտքագրում է նրանց թիվը, դուք պետք է այն համեմատեք պատահականորեն ստեղծված մեկի հետ: Եթե թվերը նույնը չեն, ձեր խաղը կարող է ստիպել խաղացողին փորձել մեկ այլ համար: Եթե թվերը համընկնում են, կարող եք ասել, որ խաղացողը ճիշտ է կռահել և դուրս գալ ծրագրից: Դա արվում է հետևյալ ծածկագրով.
իսկ userNum! = rightNum: userNum = int (մուտքագրում ())
Քայլ 8. Տվեք խաղացողի կարծիքը:
Մինչ դուք արդեն մշակել եք նրանց մուտքագրումը, նվագարկիչը դա չի տեսնի: Դուք պետք է իրականում տպեք արդյունքները խաղացողի վրա, որպեսզի նրանք հասկանան, թե ինչ է կատարվում:
- Իհարկե, դուք պարզապես կարող եք ասել խաղացողին ՝ նրանց թիվը ճիշտ է, թե սխալ: Բայց այդ մոտեցման դեպքում խաղացողը կարող է 1000 անգամ կռահել վատագույն դեպքում, ինչը շատ ձանձրալի կլիներ:
- Այսպիսով, ասեք խաղացողին, թե արդյոք նրանց թիվը չափազանց փոքր է կամ շատ մեծ: Սա զգալիորեն կնվազեցնի նրանց ենթադրությունների թիվը: Եթե, օրինակ, խաղացողը գուշակի առաջինը 500-ը, և խաղը պատասխանի «Չափազանց մեծ: Կրկին փորձիր», 1000-ի փոխարեն կլինի ընդամենը 500 հնարավոր թիվ: Դա արվում է եթե-կոնստրուկցիաներով, այնպես որ փոխարինիր տպագրությունը («Սխալ Նորից փորձիր »):
- Տեղյակ եղեք, որ երկու թվերի նույն լինելը ստուգելը կատարվում է == - ով, այլ ոչ թե = - ով: = վերագրում է դրա արժեքը աջից փոփոխականին ձախից:
if userNum <rightNum: print ("Չափազանց փոքր. Նորից փորձեք.") if userNum> rightNum: print ("Չափազանց մեծ. Նորից փորձեք.")
Քայլ 9. Փորձարկեք ձեր կոդը:
Որպես ծրագրավորող, դուք պետք է վստահ լինեք, որ ձեր ծածկագիրը գործում է նախքան այն ավարտված համարելը:
-
Python- ում ծրագրավորելիս համոզվեք, որ թեքությունները ճիշտ եք ստացել: Ձեր ծածկագիրը պետք է լինի այսպիսին.
ներմուծել պատահական տպագիր («Բարի գալուստ թվերի կռահման խաղ») տպագիր («Մուտքագրեք մի ամբողջ թիվ 1 -ից 1000 -ի միջև») rightNum = random.randint (0, 1000) userNum = մուտքագրում () userNum = int (userNum) մինչ userNum! = rightNum. ճիշտ »)
Քայլ 10. Վավերացրեք մուտքագրումը:
Խաղացողը չպետք է կարողանա խախտել ձեր խաղը ՝ պարզապես սխալ բան մտնելով: «Մուտքի վավերացում» նշանակում է համոզվել, որ խաղացողը մուտքագրել է ճիշտ բանը, նախքան այն մշակելը:
- Կրկին բացեք խաղը և փորձեք մուտքագրել այն, ինչը թիվ չէ: Խաղը կավարտվի ValueError- ով: Դրանից խուսափելու համար դուք կարող եք միջոց կիրառել ՝ ստուգելու, արդյոք մուտքագրումը թիվ էր:
- Սահմանել գործառույթ: Քանի որ մուտքի վավերացումը բավականին երկար է, և դուք պետք է դա անեք մի քանի անգամ, դուք պետք է սահմանեք գործառույթ: Այն չի տա փաստարկներ և կվերադարձնի համարը: Նախ, գրեք def numInput () ՝ ձեր ծածկագրի վերևում, անմիջապես ներմուծման պատահականության ներքո:
- Ստացեք նվագարկիչի մուտքը մեկ անգամ: Օգտագործեք input () գործառույթը և արդյունքը հանձնարարեք inp փոփոխականին:
- Երբ խաղացողի մուտքը թիվ չէ, խնդրեք նրանց մուտքագրել համար: Ստուգելու համար, թե արդյոք տողը թիվ է, օգտագործեք isdigit () գործառույթները, ինչը թույլ է տալիս միայն ամբողջ թիվը, այնպես որ ստիպված չեք լինի դա առանձին ստուգել:
- Եթե մուտքագրումը թիվ է, այն տողից փոխարկեք համարի և վերադարձեք արդյունքը: Օգտագործեք int () գործառույթը ՝ տողը ամբողջ թիվ դարձնելու համար: Սա հիմնական կոդի փոխակերպումը կդարձնի ավելորդ, և դուք պետք է այն հեռացնեք այնտեղից:
- Հիմնական ծածկագրի մուտքի () բոլոր զանգերը փոխարինեք numInput () զանգերով:
- NumInput () ֆունկցիայի ծածկագիրն այսպիսի տեսք կունենա.
def numInput (): inp = մուտքագրում () մինչդեռ inp.isdigit (): print («Ձեզ ասվել է, որ մուտքագրեք մի ամբողջ թիվ: Մուտքագրեք մի ամբողջ թիվ») inp = մուտքագրում () վերադարձ int (ներ)
Քայլ 11. Կրկին փորձարկեք խաղը:
Մտածեք սխալ բաները ՝ դիտելու, թե ինչ է տեղի ունենում, այնուհետև շտկեք ցանկացած սխալ, երբ դրանք ի հայտ գան:
Փորձեք մուտքագրել տեքստ, երբ ծրագիրը ձեզանից թիվ է պահանջում: Այժմ, սխալի հաղորդագրությամբ դուրս գալու փոխարեն, ծրագիրը նորից ձեզ համար թիվ կխնդրի:
Քայլ 12. Առաջարկեք վերսկսել խաղը, երբ այն ավարտվի:
Այսպիսով, խաղացողը կարող է ավելի երկար խաղալ ձեր խաղը ՝ առանց անընդհատ վերագործարկելու:
- Տեղադրեք ամբողջ ծածկագիրը, բացառությամբ ներմուծման և գործառույթի սահմանման, while-loop- ի մեջ: Սահմանեք True որպես պայման. Սա միշտ ճշմարիտ կլինի, ուստի օղակը կշարունակվի հավիտյան:
- Հարցրեք խաղացողին, թե արդյոք նրանք ցանկանում են նորից խաղալ այն բանից հետո, երբ նրանք ճիշտ կռահել են համարը: Օգտագործեք print () գործառույթը:
- Եթե նրանք պատասխանում են «Ոչ», պոկվեք տեսքից: Եթե նրանք այլ բան պատասխանեն, շարունակեք: Օղակից դուրս գալը կատարվում է ընդմիջման հայտարարությամբ:
- Տեղափոխեք «Բարի գալուստ թվերի կռահման խաղ» -ը while օղակից դուրս: Հավանաբար, խաղացողը չի ցանկանում ողջունվել ամեն անգամ, երբ նրանք խաղում են խաղը: Տեղափոխեք հրահանգի տպագրությունը («Բարի գալուստ թվերի կռահման խաղ»: իսկ ճշմարիտ:
Քայլ 13. Փորձարկեք խաղը:
Դուք պետք է փորձարկեք ձեր խաղը ամեն անգամ, երբ նոր գործառույթ եք կիրառում:
-
Համոզվեք, որ գոնե մեկ անգամ պատասխանեք «Այո» և «Ոչ» ՝ համոզվելու համար, որ երկու տարբերակներն էլ աշխատում են: Ահա, թե ինչպիսին պետք է լինի ձեր կոդը.
ներմուծել պատահական def numInput (): inp = մուտքագրում () մինչդեռ inp.isdigit (): print («Ձեզ ասել են, որ մուտքագրեք մի ամբողջ թիվ: Մուտքագրեք մի ամբողջ թիվ») inp = մուտքագրում () վերադարձ int (inp) տպում («Բարի գալուստ թվերի կռահման խաղ»:) մինչդեռ True: print («Մուտքագրեք մի ամբողջ թիվ 1 -ից 1000 -ի միջև») rightNum = random.randint (0, 1000) userNum = numInput () while userNum! = RightNum: if userNum <rightNum: print ("Too small. Փորձեք նորից.") if userNum> rightNum: print ("Too large. Փորձեք նորից.") userNum = numInput () print ("Դուք ճիշտ կռահեցիք") print ("Do you ուզում եք նորից խաղալ? Մուտքագրեք Ոչ, որպեսզի դուրս գաք »
Քայլ 14. Գրեք տեքստային այլ խաղեր:
Ի՞նչ կասեք հաջորդ տեքստային արկածախնդրության մասին: Կամ վիկտորինայի խաղ: Եղեք ստեղծագործ:
Հուշում Երբեմն օգտակար է փաստաթղթերում նայել, եթե վստահ չեք, թե ինչ -որ բան կատարվում է կամ ինչպես է գործառույթը օգտագործվում: Python 3 -ի փաստաթղթերը կարելի է գտնել https://docs.python.org/3/ կայքում: Երբեմն ինտերնետում փնտրելով այն, ինչ ցանկանում եք անել, նույնպես լավ արդյունքներ է տալիս:
2 -րդ մաս 3 -ից. Խաղ պատրաստելը 2D գրաֆիկայի միջոցով
Քայլ 1. Ընտրեք գրաֆիկական գրադարան:
Գրաֆիկայի ստեղծումը շատ բարդ է, և ծրագրավորման լեզուների մեծ մասը (ներառյալ Python, C ++, C, JavaScript) ապահովում են գրաֆիկայի միայն նվազագույն կամ նույնիսկ ոչ մի աջակցություն հիմնական կամ ստանդարտ գրադարաններում: Այսպիսով, դուք պետք է օգտագործեք արտաքին գրադարան, որպեսզի կարողանաք գրաֆիկա պատրաստել, օրինակ ՝ Pygame- ը 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 ներմուծումից *, որտեղ ենթամոդուլի անունն այն ենթամոդուլն է, որը ցանկանում եք ներմուծել: … Ներմուծումից * և ներմուծումից…
- Սահմանեք ColorLayer- ի MainMenuBgr ենթադասը: Սա հիմնականում նշանակում է, որ ձեր ստեղծած հիմնական ընտրացանկի ֆոնը ձեզ կպահի գունային շերտի պես ՝ որոշ փոփոխություններ կատարելով:
- Սկսեք կոկոսի տնօրենը: Սա ձեզ նոր պատուհան կտա: Եթե դուք մակագրություն չեք դնում, պատուհանը կունենա նույն մակագրությունը, ինչ ֆայլի անունը (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 = Տեսարան (MainMenuBgr ()) Director.run (menuSc) Director.init (վերնագիր = "IcyPlat - պարզ հարթակ", չափափոխելի = True) showMainMenu ()
Քայլ 6. Պատուհանին ավելացրեք հիմնական ընտրացանկ:
Բացի իրական խաղից, ձեզ հարկավոր է ավելացնել ընտրացանկ, որը խաղացողը կարող է օգտագործել պատուհանը փակելու համար, ի թիվս այլ տարրերի, որոնք կարող եք ավելացնել ավելի ուշ:
- Ներմուծեք cocos.menu (կրկին հրահանգից) և pyglet.app (այս անգամ ՝ ներմուծմամբ):
- Սահմանեք MainMenu- ն որպես ընտրացանկի ենթադաս:
- Սահմանեք հիմնական ընտրացանկի հավասարեցում: Դուք պետք է առանձին սահմանեք ուղղահայաց և հորիզոնական հավասարեցում:
- Ստեղծեք ընտրացանկի տարրերի ցուցակ և ավելացրեք դրանք ընտրացանկին: Դուք պետք է ունենաք «Սկսել խաղը» և «Դադարեցնել» ընտրացանկի տարրերը: Menuանկի յուրաքանչյուր տարր պետք է տեղադրվի փակագծերի ներսում: Յուրաքանչյուր տարր պետք է ունենա պիտակ և հետադարձման գործառույթ, որը որոշում է, թե ինչ է տեղի ունենում, երբ նվագարկիչը կտտացնում է այն: «Սկսել խաղը» կետի համար օգտագործեք 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 (Մենյու). ", startGame)), (MenuItem (" Դուրս գալ ", pyglet.app.exit))] self.create_menu (menuItems) def startGame (): pass def showMainMenu (): menuSc = Տեսարան (MainMenuBgr ()) menuSc.add (MainMenu ()) Director.run (menuSc) Director.init (caption = "IcyPlat - պարզ հարթակ", resizable = True) showMainMenu ()
Քայլ 7. Փորձարկեք ձեր կոդը:
Փորձարկեք կոդը շուտ, մինչդեռ այն դեռ կարճ է և համեմատաբար պարզ: Այնուհետև կարող եք բացահայտել և ուղղել հիմնական կառուցվածքի ցանկացած սխալ, նախքան ամեն ինչ շատ բարդանալը:
Հրահանգների ծածկագիրը պետք է պատուհան բացի `« IcyPlat - պարզ հարթակ »վերնագրով: Ֆոնը բաց կապույտ է և կարող եք չափափոխել պատուհանը: Երբ ընտրացանկում սեղմում եք «Սկսել խաղը», ոչինչ (դեռ) չպետք է պատահի: Երբ սեղմում եք «Դուրս գալ», պատուհանը կփակվի:
Քայլ 8. Ստեղծեք սպրայտ:
Sprite- ը «խաղային օբյեկտ» է կամ երկչափ պատկեր: Sprites- ը կարող են լինել խաղի առարկաներ, սրբապատկերներ, ֆոնային զարդեր, կերպարներ և այն ամենը, ինչ կարող եք ներկայացնել խաղի մեջ պատկերով: Մենք կսկսենք ՝ ստեղծելով սփրայթ կերպարի համար, որի հետ խաղացողը կարող է փոխազդել:
- Ներմուծեք cocos.sprite ենթամոդուլը ՝ from-import-express- ով:
- Գտեք պատկեր, որը ներկայացնում է սպրայտը: Դուք չեք կարող ցուցադրել սպրայտ, եթե դրա համար նկար չունեք: Դուք կարող եք նկարել մեկը կամ կարող եք այն ստանալ ինտերնետից (չնայած, եթե դուք մտադիր եք հրապարակել ձեր խաղը, ուշադրություն դարձրեք լիցենզիաներին): Այս օրինակի համար անցեք https://opengameart.org/content/tux-classic-hero-style և պահպանեք վազող պինգվինների-p.webp" />
- Ստեղծեք շերտ ՝ որպես ScrollableLayer դասի նոր օբյեկտ: Այնուհետև ստեղծեք Sprite- ը որպես Sprite օբյեկտ և դրեք դրա դիրքը (8, 250): Որպես տեղեկանք, կետը (0, 0) գտնվում է ներքևի ձախ անկյունում: Սա բավականին բարձր է, բայց դա կապահովի, որ պինգվինը չխրվի սառույցի մեջ:
- Sprite- ի շերտին ավելացրեք sprite- ը:
- Sprite- ի շերտից ստեղծեք նոր տեսարան և գործարկեք այն:
def startGame (): figLayer = ScrollableLayer () fig = Sprite ('pingu.png') fig.position = (75, 100) figLayer.add (fig) # gameSc = Scene (figLayer) Director.run (gameSc)
Քայլ 9. Երազեք ձեր բնապատկերի մասին:
Շատ խաղերում ձեր սպիրտները չպետք է պարզապես լողան դատարկության մեջ: Նրանք իրականում պետք է կանգնեն ինչ -որ մակերևույթի վրա, ինչ -որ բան իրենց շուրջը: 2D խաղերում դա հաճախ կատարվում է սալիկների հավաքածուի և սալիկների քարտեզի միջոցով: Սալիկների հավաքածուն հիմնականում ասում է, թե ինչպիսի մակերեսային քառակուսիներ և ֆոնային քառակուսիներ կան, և ինչ տեսք ունեն դրանք:
- Ստեղծեք սալիկների հավաքածու:Այս խաղի համար տեղադրված սալիկը շատ հիմնական կլինի. Մեկ սալիկ սառույցի համար և մեկ սալիկ երկնքի համար: Այս օրինակում օգտագործված սառցե սալիկն այստեղից է ՝ CC-BY-SA 3.0-ի ներքո:
- Ստեղծեք սալիկների հավաքածուի պատկեր: Դա բոլոր սալիկների պատկերն է, որոնք բոլորը պետք է լինեն նույն չափի (խմբագրեք դրանք, եթե դրանք չլինեն) և ունեն այն չափը, որը ցանկանում եք տեսնել խաղի մեջ ՝ միմյանց կողքին: Պահեք ձեր նկարը որպես icyTiles.png:
-
Ստեղծեք սալիկների հավաքածուի նկարագրությունը: Դա XML ֆայլ է: XML ֆայլը պարունակում է տեղեկատվություն այն մասին, թե որքան մեծ են սալիկները սալիկների հավաքածուի նկարում, որ նկարն օգտագործել և որտեղ գտնել այնտեղ գտնվող սալիկը: Ստեղծեք XML ֆայլ icyTiles.xml անունով ՝ ստորև նշված կոդով.
Քայլ 10. Կազմեք սալիկների քարտեզ ձեր լանդշաֆտի համար:
Կղմինդր քարտեզը այն քարտեզն է, որը սահմանում է, թե որ սալիկն ինչ մակարդակի վրա է գտնվում ձեր մակարդակում: Օրինակում դուք պետք է սահմանեք ֆունկցիա `սալիկների քարտեզներ ստեղծելու համար, քանի որ ձեռքով սալիկների քարտեզների նախագծումը շատ հոգնեցուցիչ է: Ավելի առաջադեմ խաղը սովորաբար ունենալու է ինչ -որ մակարդակի խմբագիր, բայց 2D խաղերի զարգացմանը ծանոթ լինելու համար ալգորիթմը կարող է ապահովել բավական լավ մակարդակներ:
- Պարզեք, թե քանի տող և սյունակ է անհրաժեշտ: Դրա համար էկրանի չափը բաժանեք սալիկի չափով ինչպես հորիզոնական (սյուներ), այնպես էլ ուղղահայաց (տողեր): Կլորացրեք թիվը դեպի վեր; դրա համար ձեզ անհրաժեշտ է մաթեմատիկական մոդուլի գործառույթ, ուստի ավելացրեք մաթեմատիկական ներմուծման սահմանից ձեր ծածկագրի վերևում գտնվող ներմուծումներին:
- Բացեք ֆայլը գրելու համար: Սա կջնջի ֆայլի բոլոր նախորդ բովանդակությունը, այնպես որ ընտրեք անուն, որը գրացուցակում դեռևս չկա, օրինակ ՝ levelMap.xml:
- Գրեք բացման պիտակները ֆայլում:
- Ստեղծեք սալիկների քարտեզ ՝ ըստ ալգորիթմի: Դուք օգտագործում եք ստորև նշված կոդի մեջ նշվածը, կամ կարող եք ինքնուրույն մեկով հանդես գալ: Համոզվեք, որ պատահական մոդուլից ներմուծում եք randint գործառույթը. Դա անհրաժեշտ է, որպեսզի ստորև նշված ծածկագիրը գործի, և այն, ինչ կհայտնաբերեք, հավանաբար նաև պատահական ամբողջ թվերի կարիք կունենա: Բացի այդ, համոզվեք, որ երկնքի սալիկներն ու սառույցը տեղադրեք տարբեր շերտերի մեջ. Սառույցը պինդ է, երկինքը `ոչ:
- Գրեք փակման պիտակները ֆայլի մեջ և փակեք ֆայլը:
def generateTilemap (): colAmount = առաստաղ (800 /16) * 3 # (էկրանի լայնություն / սալիկի չափ) * 3 rowAmount = առաստաղ (600 /16) # էկրանի բարձրություն / սալիկի չափ սալիկ Ֆայլ = բաց ("levelMap.xml", " w ") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) for i in range (0, colAmount):) == 10 և i! = 0: # թույլ չեն տալիս անցքեր ձվադրման կետում makeHole = Trueիշտ է j- ի միջակայքում (0, rowAmount). If makeHole: tileFile.write ('\ n') else: if j <= iceHeight. 1, 5) if iceHeight> rowAmount: # սահմանային սալիկներ չափազանց բարձր սառույցից բարձրություն ('\ n / n') i- ի միջակայքում (0, colAmount). tileFile.write ('') j միջակայքում (0, rowAmount): tileFile.write ('\ n') tileFile.write ('\ n ') tileFile.write (' / n / n ') tileFile.close ()
Քայլ 11. Displayուցադրել սալիկների քարտեզը:
Ներմուծեք ամեն ինչ cocos.tiles- ից և ապա դրա համար անցեք startGame գործառույթը:
- Ձեր startGame գործառույթի սկզբում ստեղծեք սալիկների քարտեզ ՝ օգտագործելով դրա համար սահմանված գործառույթը:
- Ստեղծեք ոլորման նոր կառավարիչ: Դա արեք անմիջապես այն գծի տակ, որտեղ դուք սփրիտը ավելացնում եք նրա շերտին:
- Ստեղծեք սալիկներ պարունակող նոր շերտ, որը կբեռնվի levelMap.xml սալիկի քարտեզից, որը ստեղծում է ձեր ստեղծած
- Ոլորման կառավարչին ավելացրեք ոչ պինդ շերտը, պինդ շերտը և սպրիտ շերտը ՝ հենց այս հերթականությամբ: Եթե ցանկանում եք, կարող եք ավելացնել z- դիրքը:
- Sprite շերտից տեսարան ստեղծելու փոխարեն այն ստեղծեք ոլորման կառավարիչից:
-
Ձեր startGame գործառույթը այժմ պետք է ունենա այս տեսքը.
def startGame (): generateTilemap () # 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 = Տեսարան (scrMang) Director.run (gameSc)
Քայլ 12. Փորձարկեք ձեր կոդը:
Դուք պետք է հաճախ փորձարկեք ձեր ծածկագիրը ՝ համոզվելու համար, որ ձեր գործադրած նոր հնարավորություններն իսկապես աշխատում են:
Օրինակում նշված կոդը այժմ պետք է ցույց տա պինգվինի հետևում սառցե բնապատկեր: Եթե պինգվինը կարծես սառույցի վրա է սավառնում, ապա դուք ոչ մի վատ բան չեք արել, և դա շտկվելու է հաջորդ քայլին:
Քայլ 13. Ավելացրեք հսկիչները:
Խաղացողը ծրագրի հետ փոխգործակցության շատ ավելի շատ եղանակներ ունի 2D խաղում, քան տեքստային խաղերում: Ընդհանուրը ներառում է նրանց գործչի տեղափոխումը, երբ ճիշտ ստեղնը սեղմված է:
- Ներմուծեք ամեն ինչ cocos.mapcolliders- ից և cocos.actions- ից: Նաև ներմուծեք բանալին pyglet.window- ից:
-
«Հայտարարել» որոշ գլոբալ փոփոխականներ: Գլոբալ փոփոխականները բաժանվում են գործառույթների միջև: Դուք իսկապես չեք կարող փոփոխականներ հայտարարել Python- ում, բայց պետք է ասել, որ գլոբալ փոփոխական գոյություն ունի հիմնական կոդի մեջ այն օգտագործելուց առաջ: Դուք կարող եք 0 -ն նշանակել որպես արժեք, քանի որ գործառույթը կհոգա հետագայում ճիշտ արժեքը նշանակելը: Այսպիսով, ներմուծման արտահայտությունների տակ ավելացրեք.
# «հայտարարում» գլոբալ փոփոխականներ ստեղնաշար = 0 scrMang = 0
-
Կարգավորեք ձեր startGame գործառույթը.
- Ասացեք, որ օգտագործում եք գլոբալ փոփոխականների ստեղնաշարը և scrMang- ը: Դա արեք ՝ գրելով գլոբալ ստեղնաշար, scrMang գործառույթի վերևում:
- Ստիպեք պատուհանը լսել ստեղնաշարի իրադարձությունները:
- Պատկերացրեք գործչին գործել PlatformerController- ի հիման վրա: Շուտով դուք կիրականացնեք այդ PlatformerController- ը:
- Ստեղծեք քարտեզի բախիչ `ամուր սալիկների և գործչի միջև բախումները կարգավորելու համար:
def startGame (). գլոբալ ստեղնաշար, scrMang generateTilemap () # 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 (keyboard) # fig.do (PlatformerController ()) mapcollider = RectMapCollider (veumpity_onon) = 'slide') 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 = Տեսարան (scrMang) Director.run (gameSc)
-
Ստեղծեք պլատֆորմի վերահսկիչ: Սա այն է, ինչը կտեղափոխի գործիչը ՝ ըստ ձեր սեղմումների:
- Սահմանեք պլատֆորմի վերահսկիչը որպես Գործողության ենթադաս:
- Սահմանեք շարժման արագությունը, թռիչքի արագությունը և ձգողականությունը:
- Սահմանեք մեկնարկի գործառույթը: Այս գործառույթը կոչվում է մեկ անգամ, երբ պլատֆորմի վերահսկիչը միացված է նկարին: Այն պետք է իր արագությունը սահմանի 0 -ի և x, և y ուղղությամբ:
- Սահմանեք քայլի գործառույթը: Այն կկրկնվի, քանի դեռ տեսարանն աշխատում է:
- Ասա քայլի գործառույթին `օգտագործել գլոբալ փոփոխականները ստեղնաշարի և scrMang- ի համար:
- Ստացեք և փոխեք արագությունը: Պահպանեք x և y արագությունը առանձին փոփոխականներում: Տեղադրեք x արագությունը 1 -ի կամ -1 -ի վրա (կախված այն բանից, թե սեղմված էր արդյոք ձախ կամ աջ ստեղնը) բազմապատկած շարժման արագության հետ: Ավելացրեք ինքնահոսություն y արագությանը: Բազմապատկեք այն պարապուրդի ժամանակ, որպեսզի այն նույն կերպ աշխատի ավելի դանդաղ սարքերի վրա: Եթե տիեզերական ստեղնը սեղմված է, և գործիչը կանգնած է գետնին, ցատկեք ՝ y արագությունը փոխելով դեպի արագություն:
- Հաշվիր, թե ուր պետք է շարժվի գործիչը: Այնուհետև թույլ տվեք, որ բախման կարգավորիչը կարգավորի այդ դիրքը, եթե այն գտնվում է ամուր սալիկի ներսում: Վերջապես, գործիչը տեղափոխեք նոր ճշգրտված դիրք:
- Պտտվող մենեջերի ուշադրությունը դարձրեք գործչի վրա: Սա հանգեցնում է նրան, որ տեսախցիկը շարժվում է ողջամիտ կերպով, երբ գործիչը շարժվում է:
class PlatformerController (Action). գլոբալ ստեղնաշար, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (self): self.target.velocity = (0, 0) def step (self, 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 () 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)
Քայլ 14. Փորձարկեք ձեր կոդը:
Եթե հետևեիք օրինակին, այժմ պետք է կարողանաք պինգվինին սլաքների ստեղներով տեղափոխել և ցատկել ՝ սեղմելով բացատը: Բացի այդ, պինգվինն այժմ պետք է ընկնի գետնին սավառնելու փոխարեն:
Քայլ 15. Ստեղծեք խաղի ավարտը:
Նույնիսկ այն խաղերը, որոնք կարող են անվերջ շարունակվել, պետք է պարտվելու հնարավորություն ունենան: Քանի որ այն մակարդակը, որը դուք կատարել եք օրինակով գործառույթով, ունի ավարտ, դուք նույնպես պետք է հնարավոր դարձնեք հաղթել ՝ դրան հասնելով: Հակառակ դեպքում խաղացողը միայն ցատկելու էր այնտեղի սառույցի բլոկների վրա, ինչը ձանձրալի կլիներ:
-
Platformer վերահսկիչի ներսում, ֆոկուսային հավաքածուից հետո, ստացեք գործչի x և y դիրքերը: Եթե y դիրքը 0 -ից փոքր է, կանչեք finishGame () գործառույթը (այն հետագայում կգրեք) ՝ «Game Over» նշումով որպես փաստարկ: Եթե x դիրքն ավելի մեծ է, քան էկրանի չափը 3 -ով բազմապատկված (դա նախկինում սահմանել եք որպես մակարդակի չափ):
posX, posY = self.target.position if posY <0: finishGame ("Game Over") վերադառնալ, եթե posX> 800*3: # մակարդակի չափի ավարտ Խաղը («Level Completed») վերադարձ
-
Սահմանեք դասի ավարտի մենյու: Այն պետք է նման լինի նախկինում սահմանած հիմնական ընտրացանկի դասին, բայց որպես վերնագիր դատարկ տող ունենալու փոխարեն այն պետք է օգտագործի փոփոխական տեքստ, որը _init_ գործառույթը վերցնում է որպես արգումենտ: Theաշացանկի տարրերը պետք է պիտակավորված լինեն «Կրկին փորձիր» և «Դուրս եկ» հիմա, սակայն այն գործառույթները, որոնք նրանք կոչում են, մնում են նույնը:
class FinishMenu (Menu). 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 (text): menuSc = Scene (MainMenuBgr ()) menuSc.add (FinishMenu (տեքստ)) Director.run (menuSc)
Քայլ 16. Ավելացրեք կրեդիտներ:
Սա այն վայրն է, որտեղ դուք վարկ եք ստանում ձեր հիանալի կոդի համար, ինչպես նաև վարկ տալիս որևէ մեկին, ով օգնել է ձեզ այդ ճանապարհին: Եթե այլ կայքի պատկեր եք օգտագործել (թույլտվությամբ), անպայման վերագրեք այդ պատկերը դրա ստեղծողին:
-
Ստեղծեք ՎԱՐԿԱՅԻՆ ֆայլ և այնտեղ մուտքագրեք ձեր բոլոր վարկերը, օրինակ ՝
Պինգվին. Kelvin Shadewing, CC0 Ice բլոկի տակ. Michał Banas digit1024 opengameart.org կայքում CC-BY-SA 3.0- ի ներքո
- Վերադարձեք ձեր Python կոդ և ներմուծեք Label cocos.text- ից:
-
Սահմանեք ենթավարկային կրեդիտի շերտ: Իր _init_ գործառույթում կարդացեք ՎԱՐԿԱՅԻՆ ֆայլը և դրա յուրաքանչյուր տողից կազմեք տեքստային պիտակ ճիշտ դիրքում:
դասի վարկեր (շերտ). def _init _ (self): super (Credits, self)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n ") i միջակայքում i (0, len (creds)): credLabel = Label (creds , font_size = 32, anchor_x =" left ", ankor_y =" top ") +1)*40 self.add (credLabel)
- Գնացեք ձեր հիմնական ընտրացանկի դաս և ավելացրեք «Վարկեր» պիտակով ընտրացանկի տարր, որը սեղմելիս կանչում է showCredits գործառույթը:
-
Սահմանեք ենթադասի ընտրացանկի BackToMainMenuButton: Դարձրեք սա մենյուն մեկ տարրով ՝ «Հետ» պիտակով, որը կանչում է showMainMenu գործառույթը: Այս «ընտրացանկը», որն ավելի շատ նման է կոճակի, պետք է ուղղահայաց լինի ներքևի մասում, իսկ հորիզոնականը ՝ վերևի:
դաս BackToMainMenuButton (Մենյու). create_menu (ընտրացանկի տարրեր)
-
Սահմանեք showCredits գործառույթը: Այն պետք է տեսարան պատրաստի MainMenuBgr շերտից և Credits շերտից և գործի դնի այդ տեսարանը:
def showCredits (): credSc = Տեսարան (MainMenuBgr ()) credSc.add (Վարկեր ()) credSc.add (BackToMainMenuButton ()) Director.run (credSc)
Քայլ 17. Ստուգեք ձեր ծածկագիրը:
Երբ կարծում եք, որ ավարտել եք ձեր ծածկագիրը, նորից պետք է այն ամբողջը նայեք: Սա կարող է օգնել ձեզ նկատել, արդյոք ինչ -որ բան կարելի է օպտիմալացնել, կամ արդյոք կան որոշ անհարկի տողեր, որոնք մոռացել եք ջնջել: Եթե հետևեցիք օրինակին, ձեր ամբողջ կոդը այժմ պետք է ունենա հետևյալ տեսքը.
cocos.director ներմուծում * cocos.menu ներմուծում * cocos.scene ներմուծումից * cocos.layer ներմուծում * cocos.sprite ներմուծումից * cocos.tiles ներմուծում * cocos.mapcolliders ներմուծում * cocos.actions ներմուծում * cocos- ից.text ներմուծում Պիտակի ներմուծում pyglet.app pyglet.window- ից մաթեմատիկա ներմուծման բանալին մաթեմատիկական ներմուծման առաստաղ պատահական ներմուծումից ինքն)._ 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 («Վարկեր», showCredits)), (MenuItem («Դուրս գալ», pyglet.app.exit))] self.create_menu (menuItems) դասի Վարկեր (շերտ): def _init _ (self). super (Credits, self)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n") for i in range (0, լեն (կրեդիտ)): credLabel = Պիտակ (կրեդիտ , font_size = 32, anchor_x = "left", anchor_y = "top") credLabel.position = 25, 500- (i+1)*40 self.add (credLabel) class BackToMainMenuButton (Menu): def _init _ (self): super (BackToMainMenuButton, self): ես, տեքստ). սուպեր (FinishMenu, self)._ init _ (տեքստ) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem («Կրկին փորձիր», startGame)), (MenuItem («Անջատել», պիգլետ) app.exit))] self.create_menu (menuItems) դաս PlatformerController (Action). գլոբալ ստեղնաշար, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def մեկնարկ (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 եթե 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 if posY <0: finishGame ("Game Over") վերադառնալ, եթե posX> 800*3: # մակարդակի չափի ավարտ Խաղը («Level Completed») վերադառնալ def finishGame (տեքստ): menuSc = Տեսարան (MainMenuBgr ()) menuSc.add (FinishMenu (տեքստ)) Director.run (menuSc) def showCredits (): credSc = Scene (MainMenuBgr ()) credSc.add (Վարկեր ()) credSc.add (BackToMainMenuBenu)) Director.run (credSc) def generateTilemap (): colAmount = առաստաղ (800 /16) * 3 # (էկրանի լայնություն / սալիկի չափս) * 3 տողԱմեթ = առաստաղ (600 /16) # էկրանի բարձրություն / սալիկի չափ սալիկ Ֆայլ = բաց ("levelMap.xml", "w") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) i in range (0, colAmount): tileFile.write ('') makeHole = Սխալ, եթե ռանդ int (0, 50) == 10 և i! = 0: # թույլ մի՛ տվեք անցքեր ձվադրման կետում makeHole = forիշտ է j- ի միջակայքում (0, rowAmount). if makeHole: tileFile.write ('\ n') else: եթե j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight+5) եթե iceHeight <0: # սահմանափակել սալիկների հեռանալը նույնպես ցածր iceHeight = randint (1, 5) if iceHeight> rowAmount: # սահմանափակել սալիկները չափազանց բարձր սառույցից ') tileFile.write (' / n / n ') i տիրույթում i- ի համար (0, colAmount): tileFile.write (' ') j միջակայքում (0, rowAmount): tileFile.write (' / n ') tileFile. գրել ('\ n') tileFile.write ('\ n / n') tileFile.close () def startGame (): գլոբալ ստեղնաշար, scrMang generateTilemap () # 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 (ստեղնաշար ard) # fig.do (PlatformerController ()) mapcollider = RectMapCollider (velocity_on_bump = 'slide') fig.collision_handler = make_collision_handler (mapcollider, solidTiles) # scrMang = ScrollingManager () scrMangTad.dd (nsoli) ավելացնել (solidTiles, z = 0) scrMang.add (figLayer, z = 1) # gameSc = Տեսարան (scrMang) Director.run (gameSc) def showMainMenu (): menuSc = Scene (MainMenuBgr ()) menuSc.add (MainMenu ()) Director.run (menuSc) window = Director.init (caption = "IcyPlat - պարզ հարթակ", resizable = True) showMainMenu ()
Քայլ 18. Ավարտվեց:
Այժմ փորձարկեք խաղը: Երբ ինչ -որ բան ծրագրում ես, պետք է ստուգես, արդյոք այն աշխատում է, երբ ինչ -որ նոր բան ես ներդրել: Բացի այդ, գուցե ձեզ դուր գա որոշ ժամանակ խաղալ ձեր գրած խաղը:
3 -րդ մաս 3 -ից ՝ Խաղի հրատարակում
Քայլ 1. Գրեք կախվածությունները:
Յուրաքանչյուրը, ով օգտագործում է այլ համակարգիչ, չի ունենա նույն ծրագրաշարը և գրադարանները, որոնք տեղադրված են ձեզ մոտ: Այսպիսով, դուք պետք է համոզվեք, որ բոլորը, ովքեր տեղադրում են ձեր խաղը, հստակ գիտեն, թե ինչ է անհրաժեշտ այն գործարկելու համար: Պետք չէ գրի առնել բոլոր կախվածությունների բոլոր կախվածությունները և այլն, այլ պետք է գոնե գրեք ձեր փաթեթների և դրանց կախվածությունները:
Քայլ 2. Համոզվեք, որ ունեք բոլոր լրատվամիջոցներից օգտվելու թույլտվություն:
Սա վերաբերում է բոլոր գրաֆիկական պատկերներին, ներառյալ 3D մոդելները, երաժշտությունը, երկխոսությունը, երաժշտությունը, գրադարանները և շրջանակները, որոնք դուք օգտագործել եք ձեր խաղի համար: Այն ամենը, ինչ ինքներդ չեք գրել:
- Հաճախ կան որոշ պայմաններ, օրինակ ՝ հեղինակին վարկ տալը կամ նույն լիցենզիայի ներքո լրատվամիջոցների փոփոխությունները կիսելը: Երբեմն դուք կկարողանաք օգտագործել գրաֆիկա ՝ առանց հեղինակներին վերագրելու, քանի դեռ խաղի համար գումար չեք գանձում: Եթե ստիպված եք հեղինակին վարկ տալ, դա արեք լավ տեսանելի վայրում, ինչպես ձեր խաղի «Վարկեր» ներդիրը:
- Կան նաև mediaԼՄ -ներ ՝ հեղինակային իրավունքով պահանջված և առանց լիցենզիայի նշված, երբեմն ՝ «Բոլոր իրավունքները պաշտպանված են» տեքստով:Եթե դա այդպես է, դուք պետք է հստակ թույլտվություն ստանաք հեղինակից, նախքան այն ձեր խաղում ներառելը:
- Գրադարանները սովորաբար թողարկվում են լիցենզիաներով, որոնք թույլ են տալիս դրանք օգտագործել որպես գրադարան: Հատկանշական բացառություն է GPL- ն `առանց կապի բացառության: Նման լիցենզիան թույլ է տալիս այն օգտագործել միայն որոշակի լիցենզիաներ ունեցող ծրագրում: Եվ դուք միշտ պետք է կարդաք լիցենզիայի առնվազն հիմնական կետերը `համոզվելու համար, որ այն, ինչ անում եք լրատվամիջոցների կամ գրադարանի հետ, թույլատրված է:
Գուշացում. Լրատվամիջոցների կամ գրադարանների օգտագործումը այնպես, որ լիցենզիան թույլ չի տալիս ձեր հրապարակած խաղում կարող է լուրջ իրավական խնդիրների առաջ կանգնեցնել: Այսպիսով, կամ հարցրեք հեղինակին, կամ ընդհանրապես խուսափեք լրատվամիջոցից, եթե վստահ չեք, որ ձեր օգտագործումը թույլատրված է:
Քայլ 3. Որոշեք այն պայմանների մասին, որոնցով ցանկանում եք հրապարակել ձեր խաղը:
Կվաճառե՞ք ձեր խաղը: Youանկանու՞մ եք թույլ տալ ուրիշներին օգտագործել ձեր պատկերներն ու գաղափարները: Թեև դուք պետք է զգույշ լինեք ձեր նախագծում օգտագործվող մեդիայի նկատմամբ, բայց սովորաբար կարող եք որոշել, թե ինչպես եք ցանկանում թույլ տալ, որ ուրիշները օգտագործեն ձեր խաղը: Դուք կարող եք օգտագործել Creative Commons CC0 լիցենզիա ՝ ձեր խաղը հանրային տիրույթում թողնելու համար: Որոշ պայմաններով բաշխում և փոփոխություն թույլ տալու համար ՝ որոշ իրավունքներ պահպանելով, փորձեք Gnu General Public License (GPL) կամ Berkeley Software Distribution (BSD) լիցենզիան: Կամ, դուք կարող եք ձեր ծրագրաշարը դարձնել սեփականության իրավունք, այսինքն ՝ ոչ ոքի թույլ չի տրվում տարածել կամ փոփոխել այն առանց ձեր թույլտվության:
Չնայած խաղեր վաճառելով հնարավոր է գումար վաստակել, սակայն դժվար թե մարդիկ գնեն ձեր առաջին խաղը, որը սովորաբար ունի քիչ հնարավորություններ և ոչ մի առանձնահատուկ բան: Բացի այդ, եթե անվճար ծրագիրը չգործի, այն ներբեռնած մարդիկ պարզապես հիասթափված կլինեն: Այնուամենայնիվ, եթե նրանք վճարեն դրա համար, նրանք հետ կպահանջեն իրենց գումարները ՝ ավելի շատ խնդիրներ առաջացնելով ինչպես ձեզ, այնպես էլ օգտվողների համար: Այսպիսով, մտածեք ձեր առաջին մի քանի ծրագրերը անվճար հասանելի դարձնելու մասին:
Քայլ 4. Որոշեք, թե ինչպես եք ցանկանում հրապարակել ձեր խաղը:
Յուրաքանչյուր մեթոդ ունի որոշ առավելություններ և թերություններ, ուստի ինքներդ պետք է որոշեք:
-
Հրապարակելով այն կայքում.
Եթե դուք ունեք կայք, կարող եք վերբեռնել ձեր խաղը `այն ներբեռնման համար հասանելի դարձնելու համար: Համոզվեք, որ տրամադրեք հստակ հրահանգներ, թե ինչպես տեղադրել ծրագրակազմը, ինչպես նաև բոլոր անհրաժեշտ կախվածությունները: Դրա թերությունն այն է, որ խաղացողները ստիպված կլինեն ձեռքով տեղադրել կախվածություններ, ինչը կարող է դժվար լինել որոշ մարդկանց համար:
-
Փաթեթների կառավարչի համար փաթեթ պատրաստելը.
Կան տարբեր փաթեթների կառավարիչներ, ինչպիսիք են apt- ը, Yum- ը և Homebrew- ը, որոնք մարդկանց համար հեշտացնում են ծրագրերի տեղադրումը Linux- ում և Linux- ում հիմնված միջավայրերում: Նրանք բոլորն ունեն տարբեր փաթեթային ձևաչափեր: Փաթեթների մեջ լավն այն է, որ դրանք ինքնաբերաբար տեղադրում են բոլոր կախվածությունները (եթե դրանք ճիշտ կազմաձևեք): Այսպիսով, խաղացողը միայն պետք է տեղադրի ձեր փաթեթը, այնուհետև կարող է խաղալ խաղը: Խնդիրն այն է, որ տարբեր հարթակներում կան բազմաթիվ տարբեր փաթեթների կառավարիչներ, այնպես որ դուք ստիպված կլինեք որոշակի աշխատանք կատարել ամենատարածված փաթեթների համար:
Քայլ 5. Ուշադրություն դարձրեք ձեր ծրագրին:
Հաշվի առեք ձեր ծրագիրը փաթեթների խոշոր պահեստում, ինչպես այն, ինչ Ubuntu- ն և Debian- ը պահպանում են, հեշտ տեղադրումներ թույլ տալու համար: Բացի այդ, տեղադրեք համապատասխան ֆորումներում, ինչպես GameDev- ի նախագծերի բաժինը կամ tigSource- ի մի մասը: Բայց մի հիասթափվեք, եթե ձեր առաջին խաղերը հայտնի չդառնան: Եթե ունեք գաղափար, որ դա շատերին է դուր գալիս, ձեր խաղը կարող է հայտնի դառնալ:
Խորհուրդներ
- Եղեք համբերատար և սովորելու պատրաստակամ: Mingրագրավորումը երբեմն կարող է հիասթափեցնել:
- Եթե ձեզ հետաքրքրում է, թե ինչպես է ինչ-որ բան արվում մեկ այլ խաղում, և խաղը բաց կոդով է, կարող եք նայել դրա սկզբնաղբյուրին:
- Մեդիա փնտրելիս փորձեք գտնել հանրային տիրույթում գտնվող բովանդակություն: Որոնեք «Creative Commons» կամ «Հանրային տիրույթ» պատկերներ և երաժշտություն և օգտագործեք այնպիսի կայքեր, ինչպիսիք են https://opengameart.org կամ
- Մի պատճենեք կոդի հիմնական հատվածները ՝ առանց լիցենզիան ստուգելու: Այն հաճախ արգելվում է, իսկ եթե ոչ, սովորաբար պահանջում է վերագրում:
- Ձեր խաղը գովազդելիս մի՛ արեք սպամ և մի գրեք անպատշաճ վայրերում: Սա, ամենայն հավանականությամբ, կստիպի ձեզ արգելափակել էջից, պարզապես նյարդայնացնում է և կվնասի ձեր հեղինակությանը:
