Tip:
Highlight text to annotate it
X
>> დავით Malan: მოდით დაწეროთ პროგრამა ჩართვის ფანჯარა და წრე
წრე bouncing უკან და მეოთხე off მარცხენა და მარჯვენა
კიდეები რომ ფანჯარა.
ამისათვის მოდით გამოვიყენოთ სტენფორდის პორტატული ბიბლიოთეკა, და მოდით პირველი
მოიცავს gevents.h ასე რომ ჩვენ შეგვიძლია მოსმენა მაუსის მოძრაობებით.
მოდით მაშინ მოიცავს gobjects.h ისე, რომ ჩვენ შეგვიძლია განვაცხადოთ, რამ, როგორიცაა ovals ან
წრეების, ნამდვილად.
და მაშინ მოდით მოიცავს gwindow.h ისე, რომ ჩვენ გრაფიკული ფანჯარა
ყველაფერი.
>> მოდით განაცხადოს მთავარი ჩვეულ რეჟიმში.
და მოდით ახლა განაცხადოს და instantiate ან შექმნა, რომ ფანჯარა, GWindow -
და ჩვენ მოვუწოდებთ ცვლადი ფანჯარა -
იღებს newGWindow.
და ჩვენ თვითნებურად, რათა ის 320 pixels by 240 pixels.
>> მოდით მომდევნო instantiate წრე.
მაგრამ instantiate ამ წრეში, ჩვენ უნდა გავაკეთოთ უფრო მეტი მუშაობა.
კერძოდ, მოდით შეავსოთ ამ წრეში ისე, რომ მთელი რამ არის
black და არა მხოლოდ გამოიკვეთოს მისი.
GOval -
ჩვენ მოვუწოდებთ მას წრე -
იღებს newGOval.
ჩვენ დააყენა ამ ოვალური 0, 110, და ჩვენ მიიღოს ოვალური 20 პიქსელი ფართო მიერ
20 pixels მაღალი - სხვა სიტყვებით, დიამეტრი 20 ან რადიუსი 10.
>> მოდით ახლა მითითებული ფერი რომ წრე უნდა იყოს ციტირებით unquote, "შავი". მოდით
ახლა ვაყენებთ მას ივსება განსაზღვრით ჭეშმარიტი.
და ახლა ბოლოს, მოდით დაამატოთ წრის ფანჯარა შემდეგნაირად, რომლის
უკანასკნელი დაემატა ყოფილი.
>> მოდით ახლა განაცხადოს ორმაგი.
ჩვენ მოვუწოდებთ მას სიჩქარე.
და გარკვეულწილად უკანონოდ, ვთქვათ, სიჩქარე ამ წრის იქნება
2.0, სხვა სიტყვებით რომ ვთქვათ, 2 pixels ყველა ერთეული დრო.
და ახლა მოდით შეგნებულად გამოიწვიოს უსასრულო ციკლი.
>> ასე რომ, როგორ უნდა გააკეთოს ამ წრეში Bounce უკან და მეოთხე?
კარგად მოდით ვივარაუდოთ, ამ მარყუჟი, რომ ყველა ერთეული დროს, ჩვენ
აპირებს გადავიდეს წრე უბრალოდ ცოტა ცოტა საფუძველზე სიჩქარე 2 pixels
ერთეულის დრო.
მაგრამ მუდმივად, ჩვენ ვაპირებთ, რომ უნდა შეამოწმეთ თუ წრე ეხება
მარჯვენა კიდეზე ეკრანზე ან მარცხენა ზღვარზე ეკრანზე, რადგან თუ ასე რომ, ჩვენ
სჭირდება Bounce, ასე ვთქვათ.
>> როგორ განახორციელოს ცნება bouncing?
თუ ჩვენ ვაპირებთ 2 პიქსელი მარჯვენა ერთეულის დრო, რომ Bounce off
მარჯვენა კიდეზე, ჩვენ შეგვიძლია უბრალოდ შეცვალოს რომ იყოს უარყოფითი 2 pixels ერთეულის
დრო, რითაც negating სიჩქარე.
ასე რომ, ფაქტობრივად, bouncing შედარებით პირდაპირი.
>> მოდით პირველი გადავა წრეში ამ ბევრი pixels გასწვრივ x-ღერძი, ამ
ბევრი pixels გასწვრივ y-ღერძი.
სხვა სიტყვებით რომ ვთქვათ, ჩვენ არ გვინდა, რომ ეს გადაადგილება გასწვრივ y-ღერძი ყველა.
ჩვენ მხოლოდ გვინდა, რომ Bounce უკან და მეოთხე მარცხენა და მარჯვენა.
>> და მოდით ახლა შეამოწმეთ შიგნით ამ მარყუჟის, თუ x-კოორდინაციას წრე პლუს
სიგანე წრე დიდია მეტია ან ტოლია
სიგანე ფანჯარა -
სხვა სიტყვებით, თუ წრის მდებარეობა პლუს სიგანე წრე
თავისთავად ახლა წარსულის ზღვარზე ფანჯარა, ჩვენ გვინდა
უკეთესი შეცვალოს ჩვენი სიჩქარე -
სიჩქარე იღებს უარყოფით სიჩქარე, რითაც flipping დადებითი
უარყოფითი ან უარყოფითი დადებითი.
მაგრამ რა, თუ წრე მოძრავი მარჯვნიდან მარცხნივ და ამიტომ ჰიტები
მარცხენა კიდეზე?
სხვა სიტყვებით, თუ x-კოორდინატს წრე არის ნაკლები ან ტოლია
0, მოდით წავიდეთ წინ და ისევ ინვერსიის ჩვენი სიჩქარე.
>> რატომ არ მე არ დაემატა სიგანე წრეში ამ
დრო, როგორც მე ადრე?
ასევე, გაითვალისწინეთ, რომ კოორდინატები ობიექტის განისაზღვრება
მისი ზედა მარცხენა კუთხეში, არა მისი ცენტრიდან.
და ამრიგად, როდესაც წრე მოძრავი მარცხნიდან მარჯვნივ, ჩვენ გვჭირდება შემოწმება
თუ არა მარჯვენა კიდეზე წრე გაიარა
მარჯვენა კიდეზე ფანჯარა.
ასე რომ გაერკვნენ, თუ რა არის, ჩვენ მიიღოს x-კოორდინაციას წრე
პლუს სიგანე წრე გადაადგილება საკუთარ თავს ზემოდან მარცხენა
კუთხეში, ეფექტურად, რათა ზედა მარჯვენა კუთხეში.
როდესაც წრე მოძრაობს მარჯვნიდან მარცხენა, იმავდროულად, ჩვენ არ უნდა
შეწუხება ასეთი გარდა ამისა, იმის გამო, რომ ზედა მარცხენა კუთხეში წრეში არის
უკვე ღირებულება ჩვენ გამოგიგზავნით მიიღონ მისაღებად x.
>> მოდით ახლა გადაადგილება დაადასტურა.
მოდით ახლა გადარჩენა, კომპილირდება და აწარმოებს ამ პროგრამა, რათა bounce,. / bounce.
და არ გვაქვს პროგრამა.
>> მაგრამ წრე მოძრაობს ასე darn სწრაფი, ეს თითქმის შეუძლებელია, რომ ნახოთ, თუ რა არის
რეალურად მიმდინარეობს.
მოდით საკმაოდ პროგრამა იძულებით მიერ დაწკაპვით X ზედა მარჯვენა
კუთხეში აქ.
მოდით ახლა დავუბრუნდეთ კოდის და ნელი რამ down ცოტა.
>> სხვა სიტყვებით რომ ვთქვათ, ამ უსასრულო loop, ვიდრე უბრალოდ და ნაბიჯი და
გადაადგილება და ისევ, რეკლამა nauseum, მოდით linger რამდენიმე მილიწამებში
გაგრძელებამდე გადავიდეს ერთხელ.
კერძოდ, მოდით, გადადით ბოლოში უსასრულო loop აქ და უბრალოდ
პაუზის, ვთქვათ, 10 მილიწამებში თითოეულ iteration.
მოდით ახლა recompile და ხელახლა პერსპექტივაში bounce.
და ახლა ჩვენ ვხედავთ ბევრად უფრო გონივრული განხორციელების, სადაც ჩვენ ვხედავთ
წრე ნამდვილად bouncing on მარცხენა და მარჯვენა კიდეზე.