როგორ დავპროგრამოთ კომპიუტერული თამაშები (სურათებით)

2024 ავტორი: Robert Blare | [email protected]. ბოლოს შეცვლილი: 2024-01-31 12:17

გაქვთ იდეა კომპიუტერული თამაშის შესახებ და გსურთ გახადოთ ის რეალური? ან ოდესმე გიფიქრიათ როგორ იწერება კომპიუტერული თამაშები? ეს wikiHow გასწავლით თუ როგორ უნდა დაწეროთ სამი ძირითადი კომპიუტერული თამაში პითონში. თქვენ დაგჭირდებათ პითონის ძირითადი გაგება და ზოგადი პროგრამირების კონცეფციები თქვენი პირველი თამაშის შესაქმნელად.

ნაბიჯები

მე –3 ნაწილი 1: ტექსტზე დაფუძნებული თამაშის შექმნა

ნაბიჯი 1. აირჩიეთ პროგრამირების ენა

ყველა პროგრამირების ენა განსხვავებულია, ასე რომ თქვენ უნდა გადაწყვიტოთ რომელი გამოიყენოთ თქვენი თამაშის დასაწერად. ყველა ძირითადი პროგრამირების ენა მხარს უჭერს ტექსტის შეყვანას, ტექსტის გამომუშავებას და if- კონსტრუქციებს (მთავარი რაც თქვენ გჭირდებათ მარტივი ტექსტის თამაშისთვის), ასე რომ შეისწავლეთ პარამეტრები და გადაწყვიტეთ რომელთან გრძნობთ თავს ყველაზე კომფორტულად და სწავლისთვის ერთგულ. აქ გასათვალისწინებელია რამდენიმე ფაქტორი:

• ძირითადად რისთვის გამოიყენება ენა?

  ზოგიერთი პროგრამირების ენა, როგორიცაა JavaScript, შექმნილია ინტერნეტისთვის გამოსაყენებლად, ზოგი კი, როგორიცაა Python, C, ან C ++, შექმნილია კომპიუტერული პროგრამების გასაშვებად. თქვენი თამაშისთვის დაისახეთ ენა გამოყენების უფრო ფართო სპექტრით, როგორიცაა Python, C, C ++ ან JavaScript.

• რამდენად რთულია სწავლა?

  მიუხედავად იმისა, რომ პროგრამის წერა უნდა იყოს საკმაოდ მარტივი რაიმე ნორმალური პროგრამირების ენაზე პრაქტიკის შემდეგ (ანუ არა სპეციალურად შექმნილი იმისათვის, რომ იყოს დამაბნეველი, როგორც მალბოლგე), ზოგი დამწყებთათვის უფრო მეგობრულია, ვიდრე სხვები. მაგალითად, Java და C მოითხოვს, რომ გაიგოთ უფრო ღრმა პროგრამირების ცნებები, ვიდრე პითონის მსგავსი, რომელიც ცნობილია თავისი უფრო ხელმისაწვდომი და პირდაპირი სინტაქსით.

• სად შემიძლია გამოვიყენო?

  თქვენ ალბათ გინდათ, რომ სხვადასხვა სისტემის ადამიანებმა, როგორიცაა Linux, Mac ან Windows, ყველამ შეძლოს თქვენი თამაშის თამაში. ასე რომ თქვენ არ უნდა გამოიყენოთ ენა, რომელიც მხარს უჭერს მხოლოდ რამდენიმე სისტემას, მაგალითად Visual Basic, რომელიც მხოლოდ Windows- ზეა მხარდაჭერილი.

ეს სტატია გამოიყენებს პითონს ტექსტზე დაფუძნებული თამაშის მაგალითებისთვის, მაგრამ თქვენ შეგიძლიათ ნახოთ როგორ ხდება კონცეფციები სხვა პროგრამირების ენაზე.

ნაბიჯი 2. მოამზადეთ თქვენი კომპიუტერი

ორი ძირითადი კომპონენტი, რაც დაგჭირდებათ, არის ტექსტური რედაქტორი, რომელშიც თქვენ დაწერთ თქვენს კოდს და შემდგენელი, რომელსაც გამოიყენებთ თამაშად გადასაქცევად. თუ გსურთ ამ სტატიაში მაგალითის მოყოლა, თქვენ უნდა დააინსტალიროთ პითონი და ისწავლოთ პროგრამების გაშვება. თუ გსურთ, შეგიძლიათ შექმნათ IDE (ინტეგრირებული დესკტოპის გარემო), რომელიც აერთიანებს რედაქტირებას, შედგენას და გამართვას ერთ პროგრამაში. პითონის IDE ეწოდება IDLE. თქვენ ასევე შეგიძლიათ გამოიყენოთ ნებისმიერი ტექსტური რედაქტორი, რომელიც მხარს უჭერს უბრალო ტექსტს, როგორიცაა Notepad for Windows, TextEdit for macOS, ან Vim for Linux.

ნაბიჯი 3. დაწერეთ კოდი მოთამაშის მისალმებისათვის

მოთამაშეს სურს იცოდეს რა ხდება და რა უნდა გააკეთოს, ასე რომ თქვენ უნდა დაბეჭდოთ მათთვის ტექსტი.

• ეს კეთდება პითონში print () ფუნქციით. გამოსაცდელად გახსენით ახალი ფაილი.py გაფართოებით, შეიყვანეთ მასში შემდეგი კოდი, შეინახეთ და გაუშვით:

  print ("კეთილი იყოს თქვენი მობრძანება რიცხვების გამოცნობის თამაშში!") print ("შეიყვანეთ მთელი რიცხვი 1 -დან 1000 -მდე:")
  

ნაბიჯი 4. შექმენით შემთხვევითი რიცხვი

მოდით გავაკეთოთ ტექსტზე დაფუძნებული თამაში, რომელიც მოთამაშეს სთხოვს გამოიცნოს სწორი რიცხვი. პირველი რაც ჩვენ უნდა გავაკეთოთ არის თამაშის დაწყებისას შემთხვევითი რიცხვის გენერირება, რათა მოთამაშე ყოველთვის არ გამოიცნოს ერთი და იგივე რიცხვი. ვინაიდან რიცხვი იგივე დარჩება პროგრამის განმავლობაში, თქვენ გსურთ შეინახოთ შემთხვევითი რიცხვი ცვლადში.

• პითონს არ აქვს ჩაშენებული შემთხვევითი რიცხვის ფუნქცია, მაგრამ მას აქვს სტანდარტული ბიბლიოთეკა (ეს ნიშნავს, რომ მომხმარებელს არ მოუწევს დამატებითი რამის დაყენება), რაც აქვს. ასე რომ, გადადით თქვენი კოდის დასაწყისში (დაბეჭდვის () ფუნქციამდე) და ჩაწერეთ ხაზის იმპორტი შემთხვევით.

• გამოიყენეთ შემთხვევითი ფუნქცია. მას ეწოდება randint (), არის შემთხვევით ბიბლიოთეკაში, რომელიც თქვენ შემოიტანეთ და იღებს მინიმალურ და მაქსიმალურ მნიშვნელობას, რომელსაც რიცხვი შეიძლება ჰქონდეს არგუმენტად. ასე რომ, დაუბრუნდით თქვენი კოდის ბოლოს და შეიყვანეთ შემდეგი ხაზი:

  rightNum = random.randint (0, 1000)
  

ნაბიჯი 5. მიიღეთ შეყვანა მოთამაშისგან

თამაშში მოთამაშეს სურს რაღაცის გაკეთება ან რაიმესთან ურთიერთობა. ტექსტზე დაფუძნებულ თამაშში ეს შესაძლებელია ტექსტის შეყვანით. ახლა, როდესაც ჩვენ გვაქვს შემთხვევითი რიცხვი, ჩვენი კოდის შემდეგი ხაზები უნდა ითხოვდეს მოთამაშეს შეიტანოს თავისი საუკეთესო გამოცნობა.

• ვინაიდან თქვენ მიერ შეყვანილი კოდი ბეჭდავს მითითებას, რომ შეიყვანოთ ნომერი მოთამაშეს, ის ასევე უნდა კითხულობდეს მათ მიერ შეყვანილ რიცხვს. ეს კეთდება შეყვანის () პითონში 3 და raw_input () პითონში 2. თქვენ უნდა დაწეროთ პითონში 3, რადგან პითონი 2 მალე მოძველდება. დაამატეთ შემდეგი ხაზი თქვენს კოდს, რომ შეინახოთ მოთამაშის შეყვანა ცვლადში, რომელსაც ეწოდება ნომერი:

  userNum = შეყვანა ()
  

ნაბიჯი 6. ჩართეთ მოთამაშის შეყვანა მონაცემების გამოსაყენებლად

მოთამაშემ შეიყვანა ნომერი-ახლა რა?

• გახადეთ მოთამაშის შეყვანა რიცხვი. ახლა, ეს შეიძლება გაუგებრად ჟღერდეს, რადგან მათ უბრალოდ შეიყვანეს ნომერი. მაგრამ არსებობს კარგი მიზეზი: პითონი მიიჩნევს, რომ ყველა შეყვანა არის ტექსტი, ან "სიმებიანი", როგორც ამას პროგრამირებაში ეძახიან. ეს ტექსტი შეიცავს ნომერს, რომლის მიღება გსურთ. პითონს აქვს ფუნქცია, რომელიც გარდაქმნის სტრიქონს, რომელიც შეიცავს მხოლოდ რიცხვს შიგნით არსებულ რიცხვში. ტიპი:

  userNum = int (userNum)
  

ნაბიჯი 7. შეადარეთ მოთამაშის ნომერი სწორ რიცხვს

მას შემდეგ რაც მოთამაშე შეიყვანს მათ რიცხვს, თქვენ უნდა შეადაროთ ის შემთხვევით გენერირებულს. თუ რიცხვები არ არის იგივე, თქვენმა თამაშმა შეიძლება აიძულოს მოთამაშე სცადოს სხვა ნომერი. თუ რიცხვები ემთხვევა, შეგიძლიათ უთხრათ მოთამაშეს, რომ ისინი სწორად გამოიცნეს და დატოვეთ პროგრამა. ეს კეთდება შემდეგი კოდით:

ხოლო userNum! = rightNum: userNum = int (შეყვანა ())

ნაბიჯი 8. მიეცით მოთამაშეს უკუკავშირი

სანამ თქვენ უკვე დამუშავებული გაქვთ მათი შეყვანა, მოთამაშე ამას ვერ დაინახავს. თქვენ რეალურად უნდა დაბეჭდოთ შედეგები მოთამაშეს, რათა მათ გაიგონ რა ხდება.

• რა თქმა უნდა, თქვენ შეგიძლიათ უბრალოდ უთხრათ მოთამაშეს მათი რიცხვი სწორია თუ არასწორი. ამ მიდგომით, მოთამაშეს შეიძლება 1000 -ჯერ უნდა გამოიცნოს უარეს შემთხვევაში, რაც ძალიან მოსაწყენი იქნებოდა.
• ასე რომ უთხარით მოთამაშეს მათი რიცხვი ძალიან მცირეა თუ ძალიან დიდი. ეს მნიშვნელოვნად შეამცირებს მათ ვარაუდებს. თუ, მაგალითად, მოთამაშე პირველად გამოიცნობს 500-ს და თამაში პასუხობს "ძალიან დიდი. სცადე ხელახლა", 1000-ის ნაცვლად იქნება მხოლოდ 500 შესაძლო რიცხვი. ეს კეთდება if- კონსტრუქციებით, ამიტომ შეცვალეთ ბეჭდვა ("არასწორი სცადე ისევ. ") ერთთან ერთად.
• გაითვალისწინეთ, რომ ორი რიცხვის ერთნაირი შემოწმება ხდება == -ით და არა = -ით. = ანიჭებს მნიშვნელობას მის მარჯვნივ ცვლადზე!

if userNum <rightNum: print ("ძალიან მცირე. სცადე ხელახლა:") თუ userNum> rightNum: print ("ძალიან დიდი. სცადე ხელახლა:")

ნაბიჯი 9. შეამოწმეთ თქვენი კოდი

როგორც პროგრამისტი, დარწმუნებული უნდა იყოთ, რომ თქვენი კოდი მუშაობს დასრულებამდე.

• პითონში პროგრამირების დროს, დარწმუნდით, რომ თქვენ სწორად აიღებთ ჩანაწერებს. თქვენი კოდი ასე უნდა გამოიყურებოდეს:

  იმპორტის შემთხვევითი ბეჭდვა ("კეთილი იყოს თქვენი მობრძანება რიცხვების გამოცნობის თამაშში!") ბეჭდვა ("შეიყვანეთ მთელი რიცხვი 1 -დან 1000 -მდე:") rightNum = random.randint (0, 1000) userNum = input () userNum = int (userNum) ხოლო userNum! = rightNum: if userNum <rightNum: print ("ძალიან მცირე. სცადე ისევ:") if userNum> rightNum: print ("ძალიან დიდი. სცადე ისევ:") userNum = int (input ()) print ("მიხვდი სწორად. ")
  

ნაბიჯი 10. შეაფასეთ შეყვანა

მოთამაშეს არ უნდა შეეძლოს თქვენი თამაშის დარღვევა უბრალოდ არასწორი რამის შეყვანით. "შეყვანის შემოწმება" ნიშნავს დარწმუნდეთ, რომ მოთამაშემ შეიტანა სწორი ნივთი მისი დამუშავების წინ.

• კვლავ გახსენით თამაში და სცადეთ შეიყვანოთ ყველაფერი, რაც რიცხვი არ არის. თამაში დასრულდება ValueError– ით. ამის თავიდან ასაცილებლად, თქვენ შეგიძლიათ განახორციელოთ გზა იმის შესამოწმებლად, იყო თუ არა შეყვანა რიცხვი.
• განსაზღვრეთ ფუნქცია. ვინაიდან შეყვანის დადასტურება საკმაოდ გრძელია და თქვენ უნდა გააკეთოთ ეს არაერთხელ, თქვენ უნდა განსაზღვროთ ფუნქცია. ის არ მიიღებს არგუმენტებს და დააბრუნებს ნომერს. პირველი, ჩაწერეთ def numInput (): თქვენი კოდის ზედა ნაწილში, უშუალოდ შემთხვევითი იმპორტის ქვეშ.
• მიიღეთ მოთამაშის შეყვანა ერთხელ. გამოიყენეთ input () ფუნქცია და მიანიჭეთ შედეგი inp ცვლადს.
• როდესაც მოთამაშის შეყვანა არ არის ნომერი, სთხოვეთ მათ შეიყვანონ ნომერი. იმის შესამოწმებლად არის თუ არა სტრიქონი რიცხვი, გამოიყენეთ isdigit () ფუნქციები, რომელიც მხოლოდ მთელ რიცხვს იძლევა, ასე რომ თქვენ არ მოგიწევთ ამის ცალკე შემოწმება.
• თუ შეყვანა არის რიცხვი, გადააკეთეთ იგი სტრიქონიდან რიცხვში და დააბრუნეთ შედეგი. გამოიყენეთ int () ფუნქცია სტრიქონის მთელ რიცხვზე გადასაყვანად. ეს გახდის ძირითად კოდში გარდაქმნას არასაჭირო და თქვენ უნდა ამოიღოთ იგი იქიდან.
• შეცვალეთ ყველა ზარი შესასვლელში () მთავარ კოდში numInput () ზარებით.
• NumInput () ფუნქციის კოდი ასე გამოიყურება:

def numInput (): inp = input () while not inp.isdigit (): print ("გითხრეს მთელი რიცხვის შეყვანა! შეიყვანე მთელი რიცხვი:") inp = input () int int (inp)

ნაბიჯი 11. ხელახლა გამოსცადეთ თამაში

შეიყვანეთ არასწორი რამ განზრახ, რომ ნახოთ რა ხდება და შემდეგ გამოასწორეთ შეცდომები, როდესაც ისინი გამოჩნდებიან.

სცადეთ შეიყვანოთ ტექსტი, როდესაც პროგრამა ითხოვს ნომერს. ახლა, შეცდომის შეტყობინებით გამოსვლის ნაცვლად, პროგრამა კვლავ მოგთხოვთ ნომერს

ნაბიჯი 12. შესთავაზეთ გადატვირთვა თამაშის დასრულების შემდეგ

ამგვარად, მოთამაშეს შეეძლო თქვენი თამაში უფრო დიდხანს ეთამაშა, მისი მუდმივი გადატვირთვის გარეშე.

• ჩადეთ ყველა კოდი იმპორტისა და ფუნქციის განსაზღვრის გარდა, ხოლო მარყუჟში. დააყენეთ True, როგორც პირობა: ეს ყოველთვის იქნება ჭეშმარიტი, ასე რომ მარყუჟი სამუდამოდ გაგრძელდება.
• ჰკითხეთ მოთამაშეს სურს თუ არა კვლავ თამაში მას შემდეგ, რაც მათ სწორად გამოიცნეს ნომერი. გამოიყენეთ ბეჭდვის () ფუნქცია.
• თუ ისინი უპასუხებენ "არა" -ს, გატეხე გარეგნობა. თუ სხვა რამეს გიპასუხებენ, განაგრძეთ. მარყუჟის გარღვევა ხდება შესვენების განცხადებით.
• გადაიტანეთ "კეთილი იყოს თქვენი მობრძანება რიცხვების გამოცნობის თამაშში" while მარყუჟის გარეთ. მოთამაშეს, ალბათ, არ სურს მისასალმებელი იყოს ყოველ ჯერზე, როდესაც თამაშობენ. გადაიტანეთ ინსტრუქციის ბეჭდვა ("კეთილი იყოს თქვენი მობრძანება რიცხვების გამოცნობის თამაშში!", ხოლო True: ზემოთ, ასე რომ, ის დაიბეჭდება მხოლოდ ერთხელ, როდესაც მომხმარებელი იწყებს პირველ თამაშს.

ნაბიჯი 13. გამოცადეთ თამაში

თქვენ უნდა შეამოწმოთ თქვენი თამაში ყოველ ჯერზე ახალი ფუნქციის განხორციელებისას.

• დარწმუნდით, რომ ერთხელ მაინც უპასუხეთ "დიახ" და "არა", რათა დარწმუნდეთ, რომ ორივე ვარიანტი მუშაობს. აი, როგორი უნდა იყოს თქვენი კოდი:

  იმპორტის შემთხვევითი def numInput (): inp = input () ხოლო არა inp.isdigit (): print ("გითხრეს მთელი რიცხვი შეიყვანე! შეიყვანე მთელი რიცხვი:") inp = input () int int (inp) print ("მოგესალმებით რიცხვების გამოცნობის თამაშში!") ხოლო True: print ("შეიყვანეთ მთელი რიცხვი 1 -დან 1000 -მდე:") rightNum = random.randint (0, 1000) userNum = numInput () ხოლო userNum! = RightNum: თუ userNum <rightNum: print ("ძალიან პატარა. სცადე ხელახლა:") if userNum> rightNum: print ("ძალიან დიდი. სცადე ხელახლა:") userNum = numInput () print ("სწორად მიხვდი") print ("Do you გსურთ ისევ თამაში? შეიყვანეთ არა გასვლისთვის. ") if input () ==" No ": შესვენება
  

ნაბიჯი 14. დაწერეთ სხვა ტექსტური თამაშები

რას იტყვით შემდეგზე ტექსტური თავგადასავლის დაწერაზე? ან ვიქტორინის თამაში? Იყავი კრეატიული.

რჩევა: ზოგჯერ დამხმარეა დოკუმენტაციაში გაცნობა, თუ არ ხართ დარწმუნებული როგორ კეთდება რაღაც ან როგორ გამოიყენება ფუნქცია. პითონ 3 -ის დოკუმენტაცია მოცემულია https://docs.python.org/3/. ზოგჯერ იმის ძებნა, რისი გაკეთებაც გსურთ ინტერნეტში, ასევე კარგ შედეგს იძლევა.

3 ნაწილი 2: თამაშის გაკეთება 2D გრაფიკით

ნაბიჯი 1. აირჩიეთ გრაფიკული ბიბლიოთეკა

გრაფიკის დამზადება ძალიან რთულია და პროგრამირების ენების უმეტესობა (მათ შორის Python, C ++, C, JavaScript) უზრუნველყოფს მხოლოდ მინიმალურ ან თუნდაც არავითარ მხარდაჭერას გრაფიკაში ძირითადი ან სტანდარტული ბიბლიოთეკებისთვის. ასე რომ თქვენ უნდა გამოიყენოთ გარე ბიბლიოთეკა, რომ შეძლოთ გრაფიკის გაკეთება, მაგალითად Pygame for Python.

თუნდაც გრაფიკული ბიბლიოთეკით, თქვენ უნდა ინერვიულოთ ისეთ საკითხებზე, როგორებიცაა მენიუს ჩვენება, როგორ შევამოწმოთ პლეერის დაწკაპუნება, ფილების ჩვენება და ა.შ. თუ გირჩევნიათ ფოკუსირება მოახდინოთ რეალური თამაშის შემუშავებაზე, შეგიძლიათ გამოიყენოთ თამაშის ძრავის ბიბლიოთეკა, როგორიცაა Unity, რომელიც ადვილად ახორციელებს ამ ნივთებს

ეს სტატია გამოიყენებს პითონს Cocos2D– ით, რათა ნახოთ თუ როგორ უნდა გააკეთოთ მარტივი 2D პლატფორმერი. ზოგიერთი კონცეფცია შეიძლება არ არსებობდეს სხვა თამაშის ძრავებში. დამატებითი ინფორმაციისთვის მიმართეთ მათ დოკუმენტაციას.

ნაბიჯი 2. დააინსტალირეთ თქვენს მიერ არჩეული გრაფიკული ბიბლიოთეკა

Cocos2D პითონისთვის არის მარტივი ინსტალაცია. მისი მიღება შეგიძლიათ https://python.cocos2d.org/index.html– დან, ან sudo pip3– ის გაშვებით, თუ Linux– ს იყენებთ, დააინსტალირეთ cocos2d.

ნაბიჯი 3. შექმენით ახალი დირექტორია თქვენი თამაშისა და მედიისთვის

თქვენ გამოიყენებთ საგნებს, როგორიცაა სურათები და ხმები თქვენს თამაშში. შეინახეთ ეს ყველაფერი იმავე დირექტორიაში, როგორც პროგრამა. ეს დირექტორია არ უნდა შეიცავდეს სხვას ისე, რომ ადვილად ნახოთ რა აქტივები გაქვთ თამაშში.

ნაბიჯი 4. შექმენით ახალი კოდის ფაილი ახალ დირექტორიაში

დაარქვით მას ძირითად, თქვენი პროგრამირების ენის ფაილის გაფართოებით. თუ თქვენ წერთ დიდ და რთულ პროგრამას, სადაც აზრი აქვს მრავალი პროგრამის ფაილს, ეს გაჩვენებთ რომელია მთავარი ფაილი.

ამ მაგალითში ჩვენ შევქმნით ფაილს სახელწოდებით main.py, რომელიც შეიცავს ჩვენს მთელ კოდს

ნაბიჯი 5. შექმენით თამაშის ფანჯარა

ეს არის გრაფიკული თამაშების ძირითადი წინაპირობა.

• შემოიტანეთ საჭირო cocos2d ქვე-მოდულები: cocos.director, cocos.scene და cocos.layer. ეს კეთდება subModuleName იმპორტიდან *, სადაც ქვემოდულის სახელი არის ქვემოდული, რომლის იმპორტიც გსურთ. განსხვავება… იმპორტს * და იმპორტს შორის არის ის, რომ თქვენ არ გჭირდებათ მოდულის სახელის დაყენება ყველაფრის წინ, რასაც იყენებთ ამ მოდულიდან პირველთან ერთად.
• განსაზღვრეთ ColorLayer– ის ქვეკლასი MainMenuBgr. ეს ძირითადად ნიშნავს იმას, რომ ნებისმიერი ძირითადი მენიუს ფონი, რომელსაც თქვენ შექმნით, იქცევა ფერთა ფენის მსგავსად, გარკვეული ცვლილებების შეტანით.
• დაიწყე cocos დირექტორი. ეს მოგცემთ ახალ ფანჯარას. თუ თქვენ არ დააყენებთ წარწერას, ფანჯარას ექნება იგივე წარწერა, როგორც ფაილის სახელი (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 - მარტივი პლატფორმა", resizable = True) showMainMenu ()

ნაბიჯი 6. დაამატეთ მთავარი მენიუ ფანჯარაში

ფაქტობრივი თამაშის გარდა, თქვენ უნდა დაამატოთ მენიუ, რომელსაც მოთამაშე გამოიყენებს ფანჯრის დახურვისთვის, სხვა ელემენტებს შორის შეგიძლიათ დაამატოთ მოგვიანებით.

• იმპორტი cocos.menu (ისევ ინსტრუქციიდან) და pyglet.app (ამჯერად იმპორტით).
• განსაზღვრეთ MainMenu როგორც მენიუს ქვეკლასი.
• დააყენეთ ძირითადი მენიუს განლაგება. ცალკე უნდა დააყენოთ ვერტიკალური და ჰორიზონტალური განლაგება.
• შექმენით მენიუს ელემენტების სია და დაამატეთ ისინი მენიუში. თქვენ უნდა გქონდეთ მენიუს ელემენტები "თამაშის დაწყება" და "გამოსვლა" მინიმუმ. თითოეული მენიუს პუნქტი უნდა განთავსდეს ფრჩხილებში. თითოეულ პუნქტს უნდა ჰქონდეს ლეიბლი და გამოძახების ფუნქცია, რომელიც განსაზღვრავს რა ხდება მოთამაშეს დაწკაპუნებისას. "თამაშის დაწყება" პუნქტისთვის გამოიყენეთ startGame ფუნქცია (თქვენ ამას მალე დაწერთ), ხოლო "დატოვება" პუნქტისთვის გამოიყენეთ "pyglet.app.exit" (უკვე არსებობს). შექმენით რეალური მენიუ self.create_menu (menuItems) დარეკვით.
• განსაზღვრეთ startGame (). ახლავე ჩააბარე განმარტება, შენ ჩაანაცვლებ მას, როდესაც წერ ნამდვილ თამაშს.
• გადადით თქვენს კოდში, სადაც შექმენით menuSc სცენა და დაამატეთ მას მთავარი მენიუს ობიექტი.

• თქვენი მთელი კოდი ახლა ასე უნდა გამოიყურებოდეს:

  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 - simple platformer", resizable = True) showMainMenu ()
  

ნაბიჯი 7. შეამოწმეთ თქვენი კოდი

შეამოწმეთ კოდი ადრე, სანამ ის ჯერ კიდევ მოკლე და შედარებით მარტივია. ამის შემდეგ თქვენ შეგიძლიათ დაადგინოთ და გამოასწოროთ ძირითადი სტრუქტურის ნებისმიერი შეცდომა, სანამ ყველაფერი ძალიან გართულდება.

ინსტრუქციის კოდმა უნდა გახსნას ფანჯარა წარწერით "IcyPlat - მარტივი პლატფორმერი". ფონი ღია ცისფერია და შეგიძლიათ ფანჯრის ზომის შეცვლა. როდესაც დააწკაპუნებთ მენიუში "თამაშის დაწყება", არაფერი არ უნდა მოხდეს (ჯერ). როდესაც დააჭირეთ ღილაკს "დატოვება", ფანჯარა დაიხურება

ნაბიჯი 8. შექმენით სპრაიტი

სპრაიტი არის "თამაშის ობიექტი", ან 2 განზომილებიანი გამოსახულება. Sprites შეიძლება იყოს თამაშის ობიექტები, ხატები, ფონის დეკორაციები, პერსონაჟები და ყველაფერი რაც თქვენ შეგიძლიათ წარმოადგინოთ თამაშში გამოსახულებით. ჩვენ დავიწყებთ პერსონაჟის სპრაიტის შექმნით, რომელთანაც მოთამაშეს შეუძლია ურთიერთქმედება.

• შემოიტანეთ cocos.sprite ქვემოდული from-import-expression.
• იპოვეთ სურათი, რომელიც წარმოადგენს სპრაიტს. თქვენ არ შეგიძლიათ აჩვენოთ სპრაიტი, თუ ამის სურათი არ გაქვთ. თქვენ შეგიძლიათ დახაზოთ ერთი, ან შეგიძლიათ მიიღოთ ინტერნეტიდან (თუმცა გაუფრთხილდით ლიცენზიებს, თუ თქვენ აპირებთ თქვენი თამაშის გამოქვეყნებას). ამ მაგალითისთვის გადადით https://opengameart.org/content/tux-classic-hero-style და შეინახეთ პინგვინების გაშვებული-p.webp" />
• შექმენით ფენა, როგორც ScrollableLayer კლასის ახალი ობიექტი. შემდეგ შექმენით Sprite როგორც 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. გაახარეთ თქვენი ლანდშაფტი

უმეტეს თამაშებში თქვენი სპირტი არ უნდა იყოს მხოლოდ სიცარიელეში. ისინი რეალურად უნდა იდგნენ რაღაც ზედაპირზე, რაღაც მათ გარშემო. 2D თამაშებში ეს ხშირად კეთდება კრამიტის ნაკრებით და კრამიტის რუქით. კრამიტის ნაკრები ძირითადად ამბობს რა სახის ზედაპირის კვადრატები და ფონის კვადრატები არსებობს და როგორ გამოიყურება ისინი.

• შექმენით კრამიტის ნაკრები.ამ თამაშის კრამიტი ძალიან ძირითადი იქნება: ერთი ფილა ყინულისთვის და ერთი კრამიტი ცისთვის. ამ მაგალითში გამოყენებული ყინულის ფილა არის აქედან, CC-BY-SA 3.0-ის მიხედვით.
• კრამიტის ნაკრების სურათის შექმნა. ეს არის ყველა კრამიტის სურათი, რომელიც უნდა იყოს ერთი და იგივე ზომის (შეცვალეთ ისინი თუ არა) და აქვს ზომა, რომლის ნახვა გსურთ თამაშში, ერთმანეთის გვერდით. შეინახეთ თქვენი სურათი როგორც icyTiles.png.

• შექმენით კრამიტის ნაკრების აღწერა. ეს არის XML ფაილი. XML ფაილი შეიცავს ინფორმაციას იმის შესახებ, თუ რამდენად დიდია ფილები კრამიტის ნაკრებში, რომელი სურათი გამოვიყენოთ და სად რომელი კრამიტი ვიპოვოთ იქ. შექმენით XML ფაილი სახელწოდებით icyTiles.xml ქვემოთ მოყვანილი კოდით:

ნაბიჯი 10. გააკეთეთ კრამიტის რუკა თქვენი ლანდშაფტისთვის

კრამიტის რუკა არის რუქა, რომელიც განსაზღვრავს რომელი კრამიტი რომელ პოზიციაზეა თქვენს დონეზე. მაგალითში, თქვენ უნდა განსაზღვროთ ფუნქცია კრამიტის რუქების შესაქმნელად, რადგან კრამიტის რუქების ხელით დიზაინი ძალიან დამღლელია. უფრო მოწინავე თამაშს ჩვეულებრივ ექნება დონის რედაქტორი, მაგრამ თამაშის 2D განვითარებისათვის გაცნობისთვის ალგორითმს შეუძლია უზრუნველყოს საკმაოდ კარგი დონე.

• გაარკვიეთ რამდენი სტრიქონი და სვეტია საჭირო. ამისათვის გაყავით ეკრანის ზომა ფილაზე ჰორიზონტალურად (სვეტები) და ვერტიკალურად (რიგები). რიცხვის დამრგვალება ზემოთ; თქვენ გჭირდებათ მათემატიკის მოდულის ფუნქცია, ასე რომ დაამატეთ მათემატიკის იმპორტის ზღვარი იმპორტს თქვენი კოდის ზედა ნაწილში.
• გახსენით ფაილი წერისთვის. ეს წაშლის ფაილის ყველა წინა შინაარსს, ასე რომ შეარჩიეთ სახელი, რომელიც ჯერ არ აქვს დირექტორიაში ფაილს, როგორიცაა levelMap.xml.
• ჩაწერეთ გახსნის ტეგები ფაილში.
• შექმენით კრამიტის რუკა ალგორითმის მიხედვით. თქვენ იყენებთ ქვემოთ მოცემულ კოდში მითითებულს, ან შეგიძლიათ თავად მოაწყოთ ერთი. დარწმუნდით, რომ შემოიტანეთ რანდიტის ფუნქცია მოდულიდან შემთხვევით: ეს საჭიროა ქვემოთ მოყვანილი კოდისთვის რომ იმუშაოს და რასაც გამოხვალთ, ალბათ ასევე დაგჭირდებათ შემთხვევითი რიცხვები. ასევე, დარწმუნდით, რომ მოათავსეთ ცის ფილები და ყინულის ფილები სხვადასხვა ფენებში: ყინული მყარია, ცა არა.
• ჩაწერეთ დახურული ტეგები ფაილში და დახურეთ ფაილი.

def generateTilemap (): colAmount = ceil (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): tileFile.write ('') makeHole = False if randint (0, 50) == 10 და მე! = 0: # არ დაუშვას ხვრელები ქვირითის წერტილში makeHole = მართალია j დიაპაზონში (0, rowAmount): if makeHole: tileFile.write ('\ n') else: if j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight+5) თუ iceHeight <0: # ზღუდავს ფილებს ძალიან დაბალი ყინულისგან სიმაღლის = randint (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. კრამიტის რუქის ჩვენება

შემოიტანეთ ყველაფერი cocos.tiles– დან და შემდეგ გადადით startGame ფუნქციაზე.

• თქვენი startGame ფუნქციის დასაწყისში შექმენით კრამიტის რუქა თქვენთვის განსაზღვრული ფუნქციის გამოყენებით.
• შექმენით ახალი გადახვევის მენეჯერი. გააკეთეთ ეს პირდაპირ იმ ხაზის ქვეშ, სადაც დაამატებთ სპრაიტს მის ფენაში.
• შექმენით ფილების შემცველი ახალი ფენა, რომელიც ჩაიტვირთება levelMap.xml კრამიტის რუქიდან თქვენი გენერირებულიTilemap ფუნქცია გენერირდება.
• დაამატეთ არასამთავრობო მყარი ფენა, მყარი ფენა და სპრაიტის ფენა გადახვევის მენეჯერს, ზუსტად ამ თანმიმდევრობით. თუ გსურთ, შეგიძლიათ დაამატოთ z- პოზიცია.
• იმის ნაცვლად, რომ შექმნათ სცენა სპრაიტის ფენიდან, შექმენით ის გადახვევის მენეჯერისგან.

• თქვენი 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– დან.

• "გამოაცხადე" ზოგიერთი გლობალური ცვლადი. გლობალური ცვლადები გაზიარებულია ფუნქციებს შორის. თქვენ ნამდვილად ვერ გამოაცხადებთ ცვლადებს პითონში, მაგრამ უნდა თქვათ, რომ გლობალური ცვლადი არსებობს მთავარ კოდში მის გამოყენებამდე. თქვენ შეგიძლიათ მიანიჭოთ 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 (velocity_on = '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 სიჩქარის შეცვლით სიჩქარეზე გადასასვლელად.
  • გამოთვალეთ, სად უნდა გადავიდეს ფიგურა. შემდეგ ნება მიეცით შეჯახების დამმუშავებელს შეცვალოს ეს პოზიცია, თუ ის მყარი კრამიტის შიგნით არის. დაბოლოს, გადაიტანეთ ფიგურა ახალ მორგებულ პოზიციაზე.
  • დააყენეთ გადახვევის მენეჯერის ყურადღება ფიგურაზე. ეს იწვევს კამერის მოძრაობას გონივრულად, როდესაც ფიგურა მოძრაობს.

  კლასი PlatformerController (მოქმედება): გლობალური კლავიატურა, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (self): self.target.velocity = (0, 0) def step (self, dt): global keyboard, scroller if dt> 0.1: # ნუ გააკეთებთ არაფერს დიდი დროის დაბრუნების დროს vx, vy = self.target.velocity vx = (კლავიატურა [გასაღები. მარჯვენა] - კლავიატურა [გასაღები. გასვლა]) * საკუთარი თავი. MOV_SPEED vy + = self. GRAVITY * dt თუ self.on_ground და კლავიატურა [გასაღები. სივრცე]: 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. შექმენით თამაშის დასასრული

თამაშებსაც კი, რომლებიც უსასრულოდ შეიძლება გაგრძელდეს, უნდა ჰქონდეთ წაგების შესაძლებლობა. ვინაიდან ფუნქციის მქონე მაგალითში გაკეთებულ დონეს აქვს დასასრული, თქვენ ასევე უნდა გახადოთ შესაძლებელი, რომ მიაღწიოთ მოგებას ამ მიზნის მიღწევით. წინააღმდეგ შემთხვევაში, მოთამაშე მხოლოდ იქ ხტუნავდა ყინულის ბლოკებზე, რაც მოსაწყენი იქნებოდა.

• პლატფორმერის კონტროლერის შიგნით, ფოკუსირების შემდეგ, მიიღეთ ფიგურის x და y პოზიცია. თუ y პოზიცია 0 -ზე ნაკლებია, დარეკეთ ფუნქცია finishGame () (ამას მოგვიანებით დაწერთ) არგუმენტის სახით "Game Over". თუ x პოზიცია უფრო დიდია, ვიდრე ეკრანის ზომა გამრავლებული 3 -ით (თქვენ ეს ადრე დაყენებული გაქვთ, როგორც დონის ზომა).

  posX, posY = self.target.position if posY <0: finishGame ("Game Over") დაბრუნდება posX> 800*3: # დონის ზომის დასრულება თამაში ("დონე დასრულებულია") დაბრუნება
  

• განსაზღვრეთ კლასის დასრულების მენიუ. ის უნდა იყოს როგორც მთავარი მენიუს კლასი, რომელიც თქვენ განსაზღვრეთ ადრე, მაგრამ სათაურის ნაცვლად ცარიელი სტრიქონის ნაცვლად, უნდა გამოიყენოს ცვლადი ტექსტი, რომელსაც _init_ ფუნქცია არგუმენტად იღებს. მენიუს ელემენტები უნდა იყოს წარწერით "სცადე ხელახლა" და "დატოვე" ახლა, მაგრამ მათ მიერ მოწოდებული ფუნქციები უცვლელი რჩება.

  კლასი 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 (მენიუს პუნქტები)
  

• განსაზღვრეთ ფუნქცია finishGame (). მან უნდა მიიღოს ტექსტი, როგორც არგუმენტი. მან უნდა შექმნას სცენა მთავარი მენიუს ფონზე, FinishMenu ტექსტური არგუმენტი გადადის ამ მენიუში. შემდეგ მან უნდა აწარმოოს ეს სცენა.

  def finishGame (ტექსტი): menuSc = სცენა (MainMenuBgr ()) menuSc.add (FinishMenu (ტექსტი)) Director.run (menuSc)
  

ნაბიჯი 16. დაამატეთ კრედიტები

ეს არის ის, სადაც თქვენ იღებთ კრედიტს თქვენი გასაოცარი კოდისათვის, ასევე მიანიჭებთ კრედიტს სხვას, ვინც დაგეხმარა ამ გზაზე. თუ თქვენ იყენებთ სურათს სხვა ვებგვერდიდან (ნებართვით), დარწმუნდით, რომ მიაკუთვნეთ ეს სურათი მის შემქმნელს.

• შექმენით კრედიტის ფაილი და ჩაწერეთ იქ თქვენი ყველა კრედიტი, მაგალითად:

  პინგვინი: კელვინი დაჩრდილვა, CC0 ყინულის ბლოკის ქვეშ: Michał Banas digit1024 on opengameart.org ქვეშ CC-BY-SA 3.0
  

• დაუბრუნდით თქვენს პითონის კოდს და შემოიტანეთ ლეიბლი cocos.text– დან.

• ქვეკლასის კრედიტების ფენის განსაზღვრა. მის _init_ ფუნქციაში წაიკითხეთ CREDITS ფაილი და გააკეთეთ ტექსტური ეტიკეტი სწორ პოზიციაში, მასში არსებული ყველა სტრიქონიდან.

  კლასის კრედიტები (ფენა): def _init _ (self): super (კრედიტები, თვით)._ 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 ") +1)*40 თვით. დამატება (credLabel)
  

• გადადით თქვენს მთავარ მენიუს კლასში და დაამატეთ მენიუს პუნქტი "კრედიტები", რომელიც დაწკაპუნებისას იძახებს ფუნქციას showCredits.

• განსაზღვრეთ ქვეკლასის მენიუ BackToMainMenuButton. გააკეთეთ ეს მენიუ ერთი ერთეულით, სახელწოდებით "უკან", რომელიც იძახებს showMainMenu ფუნქციას. ეს "მენიუ", რომელიც უფრო ჰგავს ღილაკს, უნდა იყოს ვერტიკალურად გასწორებული ქვედა და ჰორიზონტალურად ზევით.

  კლასი BackToMainMenuButton (მენიუ): def _init _ (self): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem ("self") showMainM] შექმნა_მენიუ (მენიუს ელემენტი)
  

• განსაზღვრეთ ფუნქცია showCredits. მან უნდა შექმნას სცენა MainMenuBgr ფენისა და კრედიტების ფენისგან და გაუშვას ეს სცენა.

  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.ტექსტის იმპორტი ლეიბლი იმპორტი pyglet.app pyglet.window იმპორტის გასაღები მათემატიკადან იმპორტი ceil შემთხვევითი იმპორტი randint # "გამოცხადება" გლობალური ცვლადები კლავიატურა = 0 scrMang = 0 კლასი 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 ("კრედიტები", showCredits)), (MenuItem ("Quit", pyglet.app.exit))] self.create_menu (menuItems) კლასის კრედიტები (ფენა): def _init _ (self): super (კრედიტები, თვით)._ init _ () credFile = ღია ("კრედიტები", "r") creds = credFile.read () creds = creds.split ("\ n") i დიაპაზონში (0, len (creds)): credLabel = label (creds , font_size = 32, anchor_x = "მარცხნივ", anchor_y = "ზედა") credLabel.position = 25, 500- (i+1)*40 self.add (credLabel) კლასი BackToMainMenuButton (მენიუ): def _init _ (self): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem ("უკან", showMainMenu))] self.create_menu (მენიუ self, ტექსტი): სუპერ (FinishMenu, self)._ init _ (ტექსტი) 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 დაწყების (self): self.target.velocity = (0, 0) def step (self, dt): გლობალური კლავიატურა, გადახვევა თუ dt> 0.1: # არაფერი გააკეთოთ მუშაობის დროს დიდი დროის დაბრუნებისას vx, vy = self.target.velocity vx = (კლავიატურა [გასაღები. უფლება] - კლავიატურა [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: # დონის ზომის დასრულება თამაში ("დონე დასრულებულია") def def finishGame (ტექსტი): menuSc = სცენა (MainMenuBgr ()) menuSc.add (FinishMenu (ტექსტი)) Director.run (menuSc) def showCredits (): credSc = სცენა (MainMenuBgr ()) credSc.add (კრედიტები ()) credSc.add (BackToMainMenuBenu)) Director.run (credSc) def generateTilemap (): colAmount = ceil (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): tileFile.write ('') makeHole = ყალბი თუ რანდი int (0, 50) == 10 და i! = 0: # არ დაუშვას ხვრელები ქვირითის წერტილში makeHole = მართალია j დიაპაზონში (0, rowAmount): if makeHole: tileFile.write ('\ n') სხვა: თუ j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight+5) თუ iceHeight <0: # ზღუდავს ფილების წასვლას დაბალი ყინულის სიმაღლე = რანდიტი (1, 5) თუ ყინულის სიმაღლე> მწკრივი: რაოდენობა ') tileFile.write (' / n / n ') for i in range (0, colAmount): tileFile.write (' ') j for range (0, rowAmount): tileFile.write (' / n ') tileFile.write ('\ n') tileFile.write ('\ n / n') tileFile.close () def startGame (): global keyboard, 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 () scrMang.add (nsoli) scdMangr. დამატება (solidTiles, z = 0) scrMang.add (figLayer, z = 1) # gameSc = სცენა (scrMang) Director.run (gameSc) def showMainMenu (): menuSc = სცენა (MainMenuBgr ()) menuSc.add (MainMenu ()) Director.run (menuSc) ფანჯარა = Director.init (წარწერა = "IcyPlat - მარტივი პლატფორმა", resizable = True) showMainMenu ()

• ეს არის სულ 168 სტრიქონი და 152 სტრიქონი თუ მხოლოდ კოდს ითვლით. ეს ბევრს ჰგავს, მაგრამ ასეთი რთული თამაშისთვის ეს რეალურად მცირე თანხაა.

ნაბიჯი 18. დასრულდა

ახლა გამოსცადე თამაში. როდესაც რაღაცას პროგრამირებთ, თქვენ უნდა შეამოწმოთ მუშაობს თუ არა, როდესაც განახორციელებთ რაიმე ახალს. ასევე, შეიძლება მოგეწონოთ თამაში, რომელიც თქვენ დაწერეთ გარკვეული დროის განმავლობაში.

მე –3 ნაწილი 3 – დან: თამაშის გამოქვეყნება

ნაბიჯი 1. ჩამოწერეთ დამოკიდებულებები

ვინც იყენებს სხვა კომპიუტერს, არ ექნება იგივე პროგრამული უზრუნველყოფა და ბიბლიოთეკები, როგორც თქვენ. ასე რომ, თქვენ უნდა დარწმუნდეთ, რომ ყველამ, ვინც დააინსტალირებს თქვენს თამაშს, ზუსტად იცის რა დასჭირდება მათ გასაშვებად. თქვენ არ უნდა ჩამოწეროთ ყველა დამოკიდებულება ყველა დამოკიდებულების შესახებ და ასე შემდეგ, მაგრამ თქვენ მაინც უნდა დაწეროთ თქვენი პაკეტების დამოკიდებულება და მათი დამოკიდებულებები.

ნაბიჯი 2. დარწმუნდით, რომ გაქვთ ყველა მედიის გამოყენების ნებართვა

ეს ეხება ყველა გრაფიკას, მათ შორის 3D მოდელებს, მუსიკას, დიალოგს, მუსიკას, ბიბლიოთეკებს და ჩარჩოებს, რომლებიც თქვენ გამოიყენეთ თქვენი თამაშისთვის. ყველაფერი, რაც შენ თვითონ არ დაწერე.

• ხშირად არსებობს გარკვეული პირობები, როგორიცაა ავტორის კრედიტის მიცემა ან მედიის მოდიფიკაციების გაზიარება ერთი და იგივე ლიცენზიით. ზოგჯერ თქვენ შეძლებთ გამოიყენოთ გრაფიკა შემქმნელთა მიკუთვნების გარეშე, სანამ არ გადაიხდით თამაშს. თუ ავტორის დამსახურება მოგიწევთ, გააკეთეთ ეს კარგად თვალსაჩინო ადგილას, ისევე როგორც თქვენს თამაშში "კრედიტების" ჩანართი.
• ასევე არსებობს მედია საავტორო უფლებებით მოთხოვნილი და ლიცენზიის გარეშე მითითებული, ზოგჯერ ისეთი ტექსტით, როგორიცაა "ყველა უფლება დაცულია".თუ ეს ასეა, თქვენ უნდა მიიღოთ მკაფიო ნებართვა ავტორისგან, სანამ თქვენს თამაშში ჩართავთ.
• ბიბლიოთეკები, როგორც წესი, გამოიცემა ლიცენზიებით, რაც მათ ბიბლიოთეკად გამოყენების საშუალებას აძლევს. შესამჩნევი გამონაკლისია GPL გამონაკლისის გარეშე: ასეთი ლიცენზია მხოლოდ მისი ლიცენზიების მქონე პროგრამის გამოყენების საშუალებას იძლევა. თქვენ ყოველთვის უნდა წაიკითხოთ ლიცენზიის ძირითადი პუნქტები, რათა დარწმუნდეთ, რომ რასაც აკეთებთ მედიასთან ან ბიბლიოთეკასთან დასაშვებია.

გაფრთხილება: მედიის ან ბიბლიოთეკების გამოყენება ისე, რომ ლიცენზია არ იყოს ნებადართული თქვენს მიერ გამოქვეყნებულ თამაშში შეიძლება სერიოზული სამართლებრივი პრობლემები შეგექმნათ. ასე რომ, ან ჰკითხეთ ავტორს, ან საერთოდ მოერიდეთ მედიას, თუ არ ხართ დარწმუნებული, ნებადართულია თუ არა თქვენი გამოყენება.

ნაბიჯი 3. გადაწყვიტეთ რა პირობებით გსურთ გამოაქვეყნოთ თქვენი თამაში

გაყიდი შენს თამაშს? გსურთ სხვებს მისცეთ უფლება გამოიყენონ თქვენი სურათები და იდეები? მიუხედავად იმისა, რომ თქვენ უნდა იყოთ ფრთხილად მედიაში, რომელსაც იყენებთ თქვენს პროექტში, თქვენ ჩვეულებრივ შეგიძლიათ გადაწყვიტოთ, თუ როგორ გსურთ სხვებს მისცეთ საშუალება გამოიყენონ თქვენი თამაში. თქვენ შეგიძლიათ გამოიყენოთ Creative Commons CC0 ლიცენზია თქვენი თამაშის საჯარო დომენში გასავრცელებლად. იმისათვის, რომ განაწილდეთ და შეცვალოთ ცვლილებები გარკვეულ პირობებში, გარკვეული უფლებების შენარჩუნებისას, სცადეთ Gnu General Public License (GPL) ან Berkeley Software Distribution (BSD) ლიცენზია. ან, თქვენ შეგიძლიათ გახადოთ თქვენი პროგრამული უზრუნველყოფა საკუთრების უფლება, რაც იმას ნიშნავს, რომ არავის აქვს უფლება გაავრცელოს ან შეცვალოს იგი თქვენი ნებართვის გარეშე.

მიუხედავად იმისა, რომ შესაძლებელია ფულის შოვნა თამაშების გაყიდვით, ნაკლებად სავარაუდოა, რომ ადამიანები ყიდულობენ თქვენს პირველ თამაშს, რომელსაც ჩვეულებრივ აქვს რამდენიმე მახასიათებელი და არაფერი განსაკუთრებული. ასევე, თუ უფასო პროგრამა არ მუშაობს, ადამიანები, ვინც გადმოწერეს, უბრალოდ იმედგაცრუებულნი დარჩებიან. თუ ისინი გადაიხდიან ამას, ისინი მოითხოვენ თავიანთ ფულს უკან, რაც უფრო მეტ პრობლემას შეუქმნის თქვენ და მომხმარებლებს. ასე რომ, განიხილეთ თქვენი პირველი რამდენიმე პროგრამის უფასოდ ხელმისაწვდომობა

ნაბიჯი 4. გადაწყვიტეთ როგორ გსურთ გამოაქვეყნოთ თქვენი თამაში

თითოეულ მეთოდს აქვს თავისი დადებითი და უარყოფითი მხარეები, ასე რომ თქვენ თავად უნდა გადაწყვიტოთ.

• ვებგვერდზე გამოქვეყნება:

  თუ თქვენ გაქვთ ვებგვერდი, შეგიძლიათ ატვირთოთ თქვენი თამაში, რათა ის ხელმისაწვდომი იყოს გადმოსაწერად. დარწმუნდით, რომ მიაწოდეთ მკაფიო ინსტრუქცია, თუ როგორ უნდა დააინსტალიროთ პროგრამული უზრუნველყოფა, ისევე როგორც ყველა საჭირო დამოკიდებულება. ამის მინუსი ის არის, რომ მოთამაშეებს მოუწევთ დამოკიდებულების დაყენება ხელით, რაც შეიძლება ვინმესთვის გაუჭირდეს.

• პაკეტის დამზადება პაკეტის მენეჯერისთვის:

  არსებობს სხვადასხვა პაკეტის მენეჯერი, როგორიცაა apt, Yum და Homebrew, რაც ხალხს უადვილებს პროგრამების დაყენებას Linux და Linux დაფუძნებულ გარემოში. ყველა მათგანს აქვს განსხვავებული ფორმატის პაკეტი. პაკეტების კარგი მხარე ის არის, რომ ისინი ავტომატურად აყენებენ ყველა დამოკიდებულებას (თუ მათ სწორად დააკონფიგურირებთ). ასე რომ, მოთამაშემ მხოლოდ უნდა დააინსტალიროს თქვენი პაკეტი და შემდეგ შეძლოს თამაში. პრობლემა ის არის, რომ არსებობს მრავალი განსხვავებული პაკეტის მენეჯერი სხვადასხვა პლატფორმაზე, ასე რომ თქვენ მოგიწევთ გარკვეული ძალისხმევა, რათა უზრუნველყოთ ყველა ყველაზე გავრცელებული პაკეტის უზრუნველყოფა.

ნაბიჯი 5. მიაქციეთ ყურადღება თქვენს პროგრამას

განიხილეთ თქვენი პროგრამის ატვირთვა პაკეტის მთავარ საცავში, როგორიც არის Ubuntu და Debian, რათა მარტივი ინსტალაცია მოხდეს. ასევე, განათავსეთ შესაბამისი ფორუმები, როგორიცაა GameDev– ის პროექტების განყოფილება ან tigSource– ის ნაწილი. მაგრამ ნუ იმედგაცრუებთ, თუ თქვენი პირველი თამაშები არ გახდება ცნობილი. თუ თქვენ გაქვთ იდეა, რომ ბევრს მოსწონს ეს, თქვენი თამაში შეიძლება გახდეს ცნობილი.

Რჩევები

• იყავით მოთმინება და სწავლის სურვილი. პროგრამირება შეიძლება ზოგჯერ იმედგაცრუებული იყოს!
• თუ გაინტერესებთ როგორ ხდება რაღაც სხვა თამაშში და თამაში ღიაა, შეგიძლიათ გადახედოთ მის კოდს.
• როდესაც ეძებთ მედიას, შეეცადეთ იპოვოთ შინაარსი, რომელიც არის საზოგადოებრივ დომენში. მოძებნეთ "Creative Commons" ან "Public Domain" სურათები და მუსიკა და გამოიყენეთ ვებსაიტები, როგორიცაა https://opengameart.org ან
• ნუ დააკოპირებთ კოდის ძირითად ნაწილს ლიცენზიის შემოწმების გარეშე. ის ხშირად აკრძალულია და თუ არა, ჩვეულებრივ მოითხოვს ატრიბუციას.
• თქვენი თამაშის პოპულარიზაციისას ნუ გააკეთებთ სპამს და არ განათავსებთ შეტყობინებებს არასათანადო ადგილებში. ეს, სავარაუდოდ, დაგბლოკავთ გვერდიდან, უბრალოდ შემაშფოთებელია და ზიანს აყენებს თქვენს რეპუტაციას.