ძირითადი მასალა

კურსი: კომპიუტერული პროგრამირება > თემა 5

გაკვეთილი 5: ძალები

ნიუტონის მოძრაობის კანონები

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

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

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

ძალა არის ვექტორი, რომელიც იწვევს მასის მქონე ობიექტის აჩქარებას.

კარგი ამბავი ისაა, რომ ჩვენ ვიცნობთ განსაზღვრების პირველ ნაწილს: ძალა არის ვექტორი. კიდევ კარგი, რომ მთელი სექცია დავუთმეთ ვექტორისა და PVector-ებით დაპროგრამების შესწავლას!

გადავხედოთ ნიუტონის მოძრაობის სამ კანონს ძალის კონცეფციასთან მიმართებით.

ნიუტონის პირველი კანონი

ნიუტონის პირველ კანონს, ძირითადად, ასე აღწერენ:

უძრავი სხეული რჩება უძრავი და მოძრავი სხეული რჩება მოძრავი.

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

უძრავი სხეული რჩება უძრავი და მოძრავი სხეული რჩება მოძრავი მუდმივი სიჩქარითა და მიმართულებით, თუ მათზე არ იმოქმედებს დაუბალანსებელი ძალა.

იმ დროისათვის, როცა ნიუტონი გამოჩნდა, მოძრაობის გაბატონებული თეორია — არისტოტელეს მიერ ფორმულირებული — თითქმის 2 000 წლის იყო. ის ამბობდა, რომ თუ ობიექტი მოძრაობს, საჭიროა რამენაირი ძალა მისი მოძრაობის შესანარჩუნებლად. თუ ამ ობიექტს არ აწვებიან ან არ ექაჩებიან, ის შენელდება ან გაჩერდება. არა?

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

ჩვენს ProcessingJS-ის სამყაროში ნიუტონის პირველი კანონის ხელახლა აღწერა შემდეგნაირად შეგვიძლია:

ობიექტის PVector სიჩქარე დარჩება მუდმივი, თუ ის წონასწორობის მდგომარეობაშია.

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

ნიუტონის მესამე კანონი

ამ კანონს ხშირად შემდეგნაირად აღწერენ:

ქმედება იწვევს სიდიდით ტოლ უკუქმედებას.

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

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

კანონის აღწერის უკეთესი გზა შეიძლება, იყოს:

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

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

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

რა მოხდება, თუ მანქანას მიაწვებით, როცა გორგოლაჭები გაცვიათ?

ხელახლა აღვწეროთ ნიუტონის მესამე კანონი ჩვენს ProcessingJS-ის სამყაროში:

თუ გამოვთვლით PVector f-ს, რომელიც არის ობიექტ A-ს ძალა ობიექტ B-ზე, ჩვენ აგრეთვე უნდა გამოვიყენოთ ძალა — PVector.mult(f,-1); — რომლითაც B მოქმედებს ობიექტ A-ზე.

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

ნიუტონის მეორე კანონი

და, აი, მოვედით ProcessingJS-ის პროგრამისტისთვის ყველაზე მნიშვნელოვან კანონთან.

ამ კანონს ასე აღწერენ ხოლმე:

ძალა ტოლია მასისა და აჩქარების ნამრავლის.

ან:

\vec{F} = M \vec{A}

რატომ არის ეს ჩვენთვის ყველაზე მნიშვნელოვანი კანონი? მოდით, ჩავწეროთ სხვანაირად.

\vec{A} = \vec{F} / M

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

წონა და მასა

ობიექტის მასა არის მატერიის რაოდენობის საზომი ობიექტში (ვზომავთ კილოგრამებში).

წონა, რომელიც ხშირად ერევათ მასაში, ფაქტობრივად, არის გრავიტაციის ძალა ობიექტზე. ნიუტონის მეორე კანონის მიხედვით, შეგვიძლია, ის გამოვთვალოთ, როგორც მასა გამრავლებული გრავიტაციის აჩქარებაზე (w = m * g). წონა იზომება ნიუტონებში.

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

აღვნიშნოთ, რომ ობიექტს, რომელსაც გააჩნია 1 კგ მასა დედამიწაზე, ექნება 1 კგ მასა მთვარეზე. თუმცა მისი წონა მთვარეზე დედამიწის წონის მხოლოდ 1/6 იქნება.

რას ნიშნავს მასა ProcessingJS-ის სამყაროში? ჩვენ ხომ პიქსელებთან ვმუშაობთ? უფრო მარტივით რომ დავიწყოთ, ვთქვათ, რომ ჩვენს პიქსელების წარმოსახვით სამყაროში, ყველა ობიექტს აქვს 1-ის ტოლი მასა. F/1 = F. შესაბამისად:

\vec{A} = \vec{F}

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

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

mover.applyForce(wind);

ან:

mover.applyForce(gravity);

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

Mover.prototype.applyForce = function(force) {
    this.acceleration = force;
};

ძალის დაგროვება

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

mover.applyForce(wind);
mover.applyForce(gravity);
mover.update();
mover.display();

კარგი, ცოტა ხნით დავუშვათ, რომ კომპიუტერი ვართ. პირველ ყოვლისა, ვიძახებთ applyForce()-ს ქართან ერთად, ამიტომ Mover ობიექტის აჩქარებას ახლა მიენიჭა PVector ქარი. ამის შემდეგ ვიძახებთ applyForce()-ს გრავიტაციით. ახლა Mover ობიექტის აჩქარებად დაყენებულია გრავიტაციის PVector. ამის შემდეგ ვიძახებთ update()-ს. რა ხდება update()-ში? აჩქარება ემატება სიჩქარეს.

velocity.add(acceleration);

პროგრამა შეცდომას არ გვაჩვენებს, მაგრამ ვაი! დიდი პრობლემა გვაქვს. რა არის აჩქარების მნიშვნელობა, როცა ის სიჩქარეს ემატება? ის უდრის გრავიტაციის ძალას. ქარი დავკარგეთ! თუ გამოვიძახებთ applyForce()-ს ერთზე მეტჯერ, ის გადაეწერება ყველა წინა გამოძახებას. როგორ გავუმკლავდეთ ერთზე მეტ ძალას?

სიმართლე ისაა, რომ ჩვენ დავიწყეთ ნიუტონის მეორე კანონის გამარტივებული ვერსიით. აი, უფრო ზუსტი აღწერა:

ჯამური ძალა ტოლია მასისა და აჩქარების ნამრავლის.

ან, აჩქარება ტოლია ყველა ძალის ჯამისა და მასის განაყოფის. ეს ლოგიკურია. როგორც ნიუტონის პირველ კანონში ვნახეთ, თუ ყველა ძალის ჯამი ნულის ტოლია, ობიექტი წონასწორობის მდგომარეობაშია (ანუ, არანაირი აჩქარება). ამის ჩვენეული იმპლემენტაცია არის იმ პროცესზე მიყოლა, რომელსაც ვიცნობთ ძალის დაგროვების სახელით. ეს საკმაოდ ადვილია; ყველა ძალა უნდა შევკრიბოთ. ყოველ მოცემულ მომენტში შეიძლება, იყოს 1, 2, 6, 12 ან 303 ძალა. თუ ჩვენმა ობიექტმა იცის, როგორ დააგროვოს ისინი, მაშინ მნიშვნელობა არ აქვს, რამდენი ძალა მოქმედებს მასზე.

მოდით, გადავაკეთოთ applyForce() მეთოდი ისე, რომ აჩქარებას დავამატოთ ყოველი ახალი ძალა, ანუ ვაგროვებთ მათ:

Mover.prototype.applyForce = function(force) {
    this.acceleration.add(force);
};

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

if (mouseIsPressed) {
  var wind = new PVector(0{,}5, 0);
  mover.applyForce(wind);
}

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

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

ყველაზე მარტივი გზა აჩქარების გასასუფთავებლად არის PVector-ის გამრავლება 0-ზე ყოველი update()-ის ბოლოს.

Mover.prototype.update = function() {
    this.velocity.add(this.acceleration);
    this.position.add(this.velocity);
    this.acceleration.mult(0);
};

მასასთან გამკლავება

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

\vec{F} = M \vec{A}

, და არა —

\vec{A} = \vec{F}

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

გაზომვის ერთეულები

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

აქ ჩვენი საზომი ერთეულები პიქსელები („ეს ორი წრე არის 100 პიქსელით დაშორებული“) და ანიმაციის კადრებია („ეს წრე მოძრაობს კადრში 2 პიქსელი სიჩქარით“). მასის შემთხვევაში, არ არსებობს საზომი ერთეული, რომელსაც გამოვიყენებთ. ჩვენ, უბრალოდ, მოვიგონებთ რიცხვებს. ამ მაგალითში შემთხვევითად ვირჩევთ რიცხვ 10-ს. არ არსებობს საზომი ერთეული, მაგრამ შეიძლება, მოგინდეთ თქვენი საკუთარი საზომი ერთეულის მოგონება, მაგალითად „ერთი მუგი“ ან „1 არკლი“.

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

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

var Mover = function() {
    this.mass = 10;
    this.position = new PVector(random(width), random(height));
    this.velocity = new PVector(0, 0);
    this.acceleration = new PVector(0, 0);
};

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

Mover.prototype.applyForce = function(force) {
  force.div(this.mass);
  this.acceleration.add(force);
};

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

var m1 = new Mover();
var m2 = new Mover();

var wind = new PVector(1, 0);

m1.applyForce(wind);
m2.applyForce(wind);

კიდევ ერთხელ, წარმოვიდგინოთ, რომ კომპიუტერი ვართ. m1.applyForce() იღებს ქარის ძალას (1,0), ყოფს მას მასაზე (10) და ამატებს მას აჩქარებას.

კოდი	`ქარი`
`var wind = new PVector(1, 0);`	(1, 0)
`m1.applyForce(wind)`	(0,1, 0)

კარგი. გადავიდეთ ობიექტ m2-ზე. ისიც იღებს ქარის ძალას — (1,0). მოიცა. ერთი წამით. რა არის ქარის ძალის მნიშვნელობა? თუ კარგად დავაკვირდებით, ქარის ძალა ახლა არის (0,1,0)!

გახსოვთ ეს პატარა დეტალი ობიექტებთან მუშაობაზე? JavaScript-ში ცვლადი, რომელიც ინახავს ობიექტს (მაგალითად, PVector), სინამდვილეში ინახავს მიმთითებელს ამ ობიექტზე მეხსიერებაში. როდესაც ამ ობიექტს გადასცემთ ფუნქციას, თქვენ არ გადასცემთ ასლს, თქვენ გადასცემთ ორიგინალურ მიმთითებელს. ასე რომ, თუ ფუნქცია ამ ობიექტზე ცვლილებას განახორციელებს (მაგალითად, როგორც ჩვენს შემთხვევაში, გაყოფს მას მასაზე), მაშინ ეს ობიექტი სამუდამოდ შეიცვლება!

ამიტომ ირევა საქმე აქ. ჩვენ არ გვინდა, m2-მა მიიღოს m1-ის მასაზე გაყოფილი ძალა. გვინდა, რომ მან მიიღოს ის თავდაპირველ მდგომარეობაში — (1,0). ასე რომ, უნდა დავიზღვიოთ თავი და შევქმნათ PVector f-ის ასლი, სანამ მას გავყოფთ მასაზე.

საბედნიეროდ, PVector ობიექტს აქვს მოსახერხებელი მეთოდი ასლის გასაკეთებლად — get(). get() აბრუნებს ახალ PVector ობიექტს იმავე მონაცემებით. ასე რომ, შეგვიძლია, applyForce() შემდეგნაირად გამოვასწოროთ:

Mover.prototype.applyForce = function(force) {
    var f = force.get();
    f.div(this.mass);
    this.acceleration.add(f);
};

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

Mover.prototype.applyForce = function(force) {
  var f = PVector.div(force, this.mass);
  this.acceleration.add(f);
};

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

ძალების შექმნა

ჩვენ ვიცით, რა არის ძალა (ვექტორი), და ვიცით, როგორ უნდა გამოვიყენოთ ძალა ობიექტზე (გავყოთ ის მასაზე და დავამატოთ ის ობიექტის აჩქარების ვექტორს). რა გვაკლია? ჯერ კიდევ გასარკვევი გვაქვს, როგორ მივიღოთ თვითონ ძალა. საიდან მოდიან ძალები?

ამ სექციაში შევხედავთ ორ მეთოდს ძალების შესაქმნელად ჩვენს ProcessingJS-ის სამყაროში:

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

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

var wind = new PVector(0{,}01, 0);
m.applyForce(wind);

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

var wind = new PVector(0{,}01, 0);
var gravity = new PVector(0, 0{,}1);
m.applyForce(wind);
m.applyForce(gravity);

ახლა გვაქვს 2 ძალა, სხვადასხვა მხარეს მიმართული სხვადასხვა სიდიდით, ორივე გამოყენებულია ობიექტ m-ზე. სწორი გზით მივდივართ. ჩვენ ახლა შევქმენით სამყარო ჩვენი ობიექტებისთვის ProcessingJS-ში - გარემო, რომელზეც მათ რეაგირება შეუძლიათ.

აი, როგორ გამოიყურება ჩვენი პროგრამა ამ ყველაფრის თავმოყრის შემდეგ:

უჰუ! ჩვენ დიდი მასალა დავფარეთ, მაგრამ ახლა ბევრის გაკეთება შეგვიძლია. გააგრძელეთ - ისწავლეთ ძალის გამოყენება!

ეს „ბუნებრივი სიმულაციების" კურსი ეფუძნება დანიელ შიფმენის წიგნს "კოდის ბუნებას", ის გამოყენებულია ლიცენზიით Creative Commons Attribution-NonCommercial 3,0 Unported License.

გსურთ, შეუერთდეთ დისკუსიას?

შესვლა

დავალაგოთ:

პოსტები ჯერ არ არის.

გესმით ინგლისური? დააწკაპუნეთ აქ და გაეცანით განხილვას ხანის აკადემიის ინგლისურენოვან გვერდზე.