Հիմնական նյութ

Դասընթաց․ (Ծրագրավորում) > Բաժին 5

Դաս 4: Ուժեր

Նյուտոնի օրենքները

Նախորդ բաժնի վերջին օրինակում քննարկեցինք՝ ինչպես կարող ենք դինամիկ կերպով արագացում հաշվել՝ օգտվելով էկրանի վրա գտնվող առարկայից դեպի մկնիկ ուղղված վեկտորից։ Արդյունքում ստացվեց շարժում, որը նման էր շրջանի և մկնիկի միջև մագնիսական ձգողության. կարծես ինչ-որ բան շրջանին ձգում էր դեպի մկնիկը։

Այս բաժնում «ուժ» հասկացության վերաբերյալ մեր պատկերացումներն ավելի հստակ կձևակերպենք և կդիտարկենք դրա հարաբերությունը արագացման հետ։ Բաժնի վերջում մեր նպատակն է հասկանալ, թե ինչպես են բազմաթիվ օբյեկտներ շարժվում էկրանի շուրջ և ինչպես են դրանք արձագանքում միջավայրում առկա ուժերին։

Կոդով ուժը նմանակել փորձելուց առաջ փորձենք հասկանալ՝ ինչ է նշանակում իրական աշխարհում ուժ լինել։ Ճիշտ «վեկտոր» բառի նման՝ «ուժ» բառը հաճախ տարբեր իմաստներով է օգտագործվում։ Հաճախ խոսում են մարդկային ուժի մասին, օրինակ՝ «մեծ ուժով սեղանը տեղաշարժեց», կամ կամքի մասին խոսելիս, օրինակ՝ «կամքի ուժ ունի»։ Սակայն մեզ հետաքրքրող ուժի սահմանումը շատ ավելի ֆորմալ է և գալիս է Իսահակ Նյուտոնի շարժման օրենքներից.

Ուժը վեկտոր է, որը զանգված ունեցող առարկային ստիպում է արագացում ձեռք բերել։

Սահմանման առաջին մասին արդեն ծանոթ ենք. ուժը վեկտոր է։ Շատ լավ է, քանի որ մենք մի ամբողջ բաժին վեկտորներ էինք ուսումնասիրում ու PVector-ների միջոցով ծրագրավորում։

Այժմ դիտարկենք շարժման վերաբերյալ Նյուտոնի երեք օրենքները՝ կենտրոնանալով «ուժ» հասկացության վրա։

Նյուտոնի առաջին օրենք

Նյուտոնի առաջին օրենքը սովորաբար սահմանում են այսպես՝

Դադարի վիճակում գտնվող մարմինը մնում է դադարի վիճակում, շարժվող մարմինը շարունակում է շարժվել։

Այնուամենայնիվ, այստեղ ուժի հետ կապված մի փոքր հատված պակասում է։ Կարող ենք օրենքն ավելի լայն ներկայացնել այսպես՝

Դադարի վիճակում գտնվող մարմինը մնում է դադարի վիճակում, շարժվող մարմինը շարունակում է հաստատուն արագությամբ և ուղղությամբ շարժվել, քանի դեռ այլ ուժ չի կիրառվել մարմնի վրա։

Երբ Նյուտոնն սկսեց իր աշխատանքը, այդ պահին ընդունված շարժման տեսությունը, որը զարգացրել էր Արիստոտելը, արդեն 2000 տարեկան էր։ Ըստ այդ տեսության, եթե մարմինը շարժվում էր, ապա այն շարժման մեջ պահելու համար անհրաժեշտ էր լրացուցիչ ուժ կիրառել։ Չէ՞ որ եթե մարմինը չքաշեն կամ հրեն, այն կդանդաղի ու դադար կառնի։

Իրականում այդպես չէ։ Ուժերի լիարժեք բացակայության դեպքում մարմինը շարժման մեջ պահելու համար լրացուցիչ ուժ գործադրել պետք է։ Մեր մոլորակում շպրտված առարկան, օրինակ՝ գնդակը, դանդաղում է օդի դիմադրության պատճառով (օդի դիմադրությունը ուժ է)։ Առարկայի արագությունը հաստատուն կմնա միայն այն դեպքում, երբ բացակայում է ցանկացած ուժ, կամ կիրառված ուժերն իրար չեղարկում են՝ կիրառված ուժերի գումարը 0 է։ Այս վիճակը սովորաբար կոչվում է հավասարակշռություն։ Ընկնող գնդակի արագությունը կդառնա հաստատուն, երբ օդի դիմադրությունը հավասար լինի երկրի ձգողությանը։

ProcessingJS-ի աշխարհում Նյուտոնի առաջին օրենքը կարող ենք ձևակերպել այսպես՝

Օբյեկտի PVector արագությունը կմնա հաստատուն, եթե այն գտնվում է հավասարակշռության մեջ։

Մի պահ բաց թողնենք Նյուտոնի երկրորդ՝ մեզ համար ամենակարևոր օրենքը, և քննարկենք երրորդ օրենքը։

Նյուտոնի երրորդ օրենք

Այս օրենքը հաճախ ձևակերպում են այսպես՝

Մարմինները միմյանց հետ փոխազդում են նույն բնույթի՝ մոդուլով հավասար և ուղղությամբ հակադիր ուժերով։

Այս օրենքի ձևակերպումը հաճախ շփոթեցնում է մարդկանց։ Նախ տպավորություն է ստեղծվում, որ մի ուժը մյուս ուժի ստեղծման պատճառ է հանդիսացել։ Դե, իհարկե, եթե մեկին հրես, միգուցե ինքն էլ որոշի քեզ հրել, բայց Նյուտոնի երրորդ օրենքն այսպիսի փոխազդեցությունների մասին չէ։

Ենթադրենք՝ պատն ես հրում։ Պատը քեզ չի հրում։ Չկա ուժի «սկզբնակետ»։ Պարզապես քո հրման արդյունքում երկու ուժ է առաջանում՝ ազդող և հակազդող ուժեր։

Ավելի ընկալելի ձևակերպում է հետևյալը.

Ուժերը միշտ զույգով են առաջանում։ Դրանք նույն ուժգնությունն ունեն, բայց տարբեր ուղղություններ։

Սա էլ է հաճախ շփոթեցնում, քանի որ տպավորություն է ստեղծվում, որ այդ ուժերն իրար կչեղարկեն, սակայն այդպես չէ։ Ուշադրություն դարձրու, որ այդ ուժերը տաբրեր մարմինների վրա են ազդում։ Ուժերի իրար հավասար լինելը չի նշանակում, որ շարժումներն էլ են նույնը, կամ որ առարկան կդադարի շարժվել։

Փորձիր անշարժ բեռնատարը հրել։ Չնայած որ բեռնատարը քեզնից ավելի ուժեղ է, ի տարբերություն շարժվող բեռնատարի, անշարժ բեռնատարը քեզ երբեք հետ չի հրի։ Դրա վրա կիրառված քո ուժը հավասար և հակառակ է այն ուժին, որը բեռնատարը կիրառում է քո ձեռքերի վրա։ Վերջնարդյունքը տարբեր գործոններից է կախված։ Եթե բեռնատարը մի փոքր սառած զառիթափի վրա է, հավանական է, որ այն կշարժվի։ Մյուս կողմից, եթե բեռնատարը ցեխոտ լայն ճանապարհի վրա է, հավանական է, որ ձեռքդ վնասես հրելիս, մանավանդ, եթե փորձես սկզբում վազել, հետո հրել այն։

Իսկ ի՞նչ կպատահի, եթե բեռնատարը հրես անվաչմուշկներ հագած։

Վերաձևակերպենք Նյուտոնի երրորդ օրենքը ProcessingJS-ի աշխարհում.

Եթե A օբյեկտի կողմից B օբյեկտի վրա կիրառված PVector տեսակի f ուժ հաշվենք, պետք է նաև B օբյեկտի կողմից A օբյեկտի վրա կիրառվող ուժ PVector.mult(f; -1) ստեղծենք։

Կտեսնես, որ ProcessingJS ծրագրավորման ընթացքում ժամանակ առ ժամանակ այդ օրենքին չենք հետևի։ Կլինեն դեպքեր, երբ կցանկանանք հավասար ու հակադիր ուժեր ծրագրավորել, օրինակ՝ մարմինների միջև ձգողականություն ծրագրավորելիս։ Կլինեն նաև դեպքեր, երբ չենք ծրագրավորի հակադարձ ուժ. օրինակ, երբ քամու գործադրած ուժը ծրագրավորենք, պարտադիր չէ քամու վրա մարմնի կիրառած ուժն էլ գրել։ Ասեմ ավելին՝ օդն ընդհանրապես չենք մոդելավորելու։ Հիշիր, որ մենք «օգտվում ենք» բնական աշխարհի ֆիզիկայից, բայց կարիք չկա ամեն ինչ շատ ճիշտ նմանակելու։

Նյուտոնի երկրորդ օրենք

Սա ProcessingJS-ի ծրագրավորողի համար ամենակարևոր օրենքն է։

Սովորաբար այն ձևակերպում են այսպես՝

Ուժը հավասար է զանգվածի և արագացման արտադրյալին։

Կամ՝

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

Փորձենք հասկանալ՝ ինչու է սա ամենակարևոր կանոնը։ Նախ արի վերաձևակերպենք օրենքը.

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

Արագացումն ուղիղ համեմատական է ուժին և հակադարձ համեմատական՝ զանգվածին։ Այսինքն՝ ինչքան ուժեղ քեզ հրեն, այնքան ավելի արագ կշարժվես ու կարագանաս։ Ինչքան ավելի «մեծ» լինես, այնքան ավելի դանդաղ կշարժվես։

Կշիռ և զանգված

Առարկայի զանգվածը դրա մեջ պարունակվող նյութի քանակն է (չափվում է կիլոգրամներով)։

Կշիռը, որը հաճախ շփոթում են զանգվածի հետ, առարկայի վրա ձգողականության կիրառած ուժն է։ Նյուտոնի երկրորդ օրենքի միջոցով կարող ենք հաշվել կշիռը՝ զանգվածը ազատ անկման արագացմամբ բազմապատկելով (w = m * g)։ Կշիռը չափում են Նյուտոնով։

Խտությունը ծավալի մեկ միավորում զանգվածի քանակն է, օրինակ՝ մեկ սանտիմետր խորանարդում գրամները։

Ուշադրություն դարձրու, որ աշխարհի վրա մեկ կիլոգրամ զանգված ունեցող առարկան լուսնի վրա էլ մեկ կիլոգրամ կլիներ։ Այնուամենայնիվ, կշիռը կլիներ Երկրի վրա կշռի մեկ վեցերորդը։

Իսկ ի՞նչ է զանգվածը ProcessingJS-ի աշխարհում։ Չէ՞ որ խոսքը պիքսելների մասին է։ Սկզբի համար ենթադրենք, որ այս պիքսելներով աշխարհում բոլոր առարկաների զանգվածը 1 է. F/1 = F և այլն։

\vec{A} = \vec{F}

Այդ դեպքում արագացումը հավասար է ուժին։ Դա մեր գործը շատ հեշտացնում է, որովհետև «Վեկտորներ» բաժնում տեսանք, որ արագացման շնորհիվ կարող ենք էկրանի բոլոր առարկաները շարժել. դիրքը որոշվում է արագությամբ, իսկ արագությունը՝ արագացմամբ։ Արագացումն ամեն ինչի սկիզբն էր, իսկ հիմա պարզեցինք, որ ամեն ինչի սկիզբը իրականում ուժն է։

Այժմ կիրառենք մեր սովորածը Mover օբյեկտն ընդլայնելու համար. այս պահին այն ունի դիրք, արագություն և արագացում։ Այժմ ցանկանում ենք օբյեկտում ուժեր գրել, օրինակ՝ այսպես.

mover.applyForce(wind);

կամ՝

mover.applyForce(gravity);

Այստեղ քամին ու ձգողությունը (wind, 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);
}

Երբ օգտատերը մուկն այլևս չսեղմի, քամին կանգ կառնի, և, ըստ Նյուտոնի առաջին օրենքի, առարկան կշարունակի շարժվել հաստատուն արագությամբ։ Այնուամենայնիվ, եթե մոռանանք արագացումը դարձնել զրո, ուժեղ քամին դեռ կփչի։ Ասեմ ավելին՝ յուրաքանչյուր կադրում այն կգումարվի ինքն իրեն, քանի որ ուժերը կուտակում ենք։

Մեր նմանակչում արագացումը «հիշողություն» չունի. այն հաշվարկվում է տվյալ պահին՝ ըստ այդ պահին առկա ուժերի։ Սա իրականում տարբերվում է դիրքից, որը պետք է իրականում «հիշի», թե նախորդ կադրում առարկան որտեղ էր, որպեսզի կարողանա ճիշտ շարժվել։

Յուրաքանչյուր կադրում արագացումը զրո դարձնելու ամենահեշտ ձևը update() հրամանի վերջին PVector-ը զրոյով բազմապատկելն է։

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}

։ Զանգվածը ներառելը բավականին հեշտ է, նման է օբյեկտին հատկություն ավելացնելուն։ Այնուամենայնիվ, մի փոքր ավել ժամանակ պետք է ծախենք, որովհետև բարդություն է առաջանալու։

Չափման միավորներ

Զանգվածի մասին խոսելիս կարևոր է խոսել նաև չափման միավորների մասին։ Իրական աշխարհում առարկաները որոշակի միավորներով են չափվում։ Օրինակ՝ երկու առարկաների հեռավորությունը 3 մետր է, գնդակը շարժվում է 10 կմ/ժամ արագությամբ, պայուսակի կշիռը 3 կգ է։ Ավելի ուշ կտեսնենք, որ գոյություն ունեն դեպքեր, երբ կարիք կլինի իրական աշխարհի չափման միավորները հաշվի առնել։ Այնուամենայնիվ, այս բաժնում հիմնականում դրանք չենք կիրառելու։

Այստեղ մեր չափման միավորները պիքսելներն ու անիմացիայի կադրերն են. օրինակ՝ երկու շրջանների հեռավորությունը 100 պիքսել է, կամ շրջանը շարժվում է 2 պիքսել/կադր արագությամբ։ Զանգվածի համար պատրաստի չափման միավոր չկա, հետևաբար ուղղակի թվեր ենք ստեղծելու։ Այս օրինակում պատահական 10 թիվն ենք ընտրում։ Ճիշտ է, չափման միավոր չկա, բայց ազատ ես քո չափման միավորը հորինելու, օրինակ՝ «1 մոք» կամ «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)։ Սակայն իրականում խնդիրն այն է, որ քամու ուժի արժեքն արդեն (1; 0) չէ։ Ուշադիր նայիր, քամու ուժի արժեքն այս պահին իրականում (0,1; 0) է։

Հիշո՞ւմ ես օբյեկտների հետ աշխատելու այս մանրուքը։ JavaScript-ում օբյեկտ պարունակող փոփոխականը, օրինակ՝ PVector, իրականում հիշողության մեջ պահում է այդ օբյեկտի ցուցիչը։ Օբյեկտը ֆունկցիային փոխանցելիս ոչ թե հենց օբյեկտն ես փոխանցում, այլ դրա ցուցիչը։ Հետևաբար, երբ ֆունկցիան փոփոխում է օբյեկտը, օրինակ՝ բաժանում զանգվածի վրա, օբյեկտը մշտական փոփոխության է ենթարկվում։

Դրա պատճառով է այս խնդիրն առաջանում։ m1-ի զանգվածի վրա բաժանած ուժի փոխարեն ցանկանում ենք, որ m2-ը սկզբնական ուժն ստանա՝ (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 օբյեկտ, փոխանցում նախնական արժեքներ, փոխանցում այն ինչ-որ օբյկետի, որն էլ փոխանցված արժեքը կկիրառի իր արագացման վրա։ Եթե ցանկանայինք երկու ուժ գործադրել, օրինակ՝ քամի և ձգողականություն, որն ավելի ուժեղ ու դեպի ներքև ուղղված կլիներ, կարող էինք գրել այսպես.՝

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

Այս պահին ունենք տարբեր ուղղության ու տարբեր երկարության երկու ուժ, որոնք գործադրվում են m օբյեկտի վրա։ Կարծես մոտենում ենք մեր նպատակին։ ProcessingJS-ում մեր առարկաների համար աշխարհ ստեղծեցինք, որին կարող են դրանք հակազդել։

Երբ մեր ամբողջ գրածը միացնում ենք իրար, ստանում ենք հետևյալ ծրագիրը.

Շատ լավ է, բավականին շատ բան սովորեցինք։ Շարունակիր առաջ գնալ. սովորիր ուժեր կիրառել։

«Բնական նմանակիչներ» դասընթացը ստեղծվել է Դանիել Շիֆմանի «Կոդի բնույթը» գրքի հիման վրա և կիրառվում է ըստ Creative Commons Attribution-NonCommercial 3,0 Unported License-ի։

Ուզո՞ւմ ես միանալ խոսակցությանը։

Մուտք գործել

Դասակարգել ըստ

Առայժմ հրապարակումներ չկան։

Անգլերեն հասկանո՞ւմ ես: Սեղմիր այստեղ և ավելի շատ քննարկումներ կգտնես «Քան» ակադեմիայի անգլերեն կայքում: