1
00:00:00,877 --> 00:00:06,001
חזרנו לתוכנה שלנו שמציירת את וינסטון, אבל הוספתי לה קצת טקסט.

2
00:00:06,001 --> 00:00:11,072
רואים, מה שאני רוצה לעשות זה למקם את וינסטון מתחת לכל אחת מהתוויות האלו,

3
00:00:11,072 --> 00:00:13,210
על מנת להראות אותו בכל נקודה בחיים שלו.

4
00:00:13,210 --> 00:00:15,197
אבל כרגע הוא מפוזר בכל מקום.

5
00:00:15,197 --> 00:00:20,449
זה בגלל שהגדרנו את faceX ו-faceY לערכים רנדומלים בתוך הפונקציה הזו.

6
00:00:20,449 --> 00:00:26,714
בקמום, מה שאנחנו רוצים להגיד לתוכנה זה ״היי, הנה כמה מיקומים מדוייקים שבהם אני רוצה שתציירי את וינסטון״

7
00:00:26,714 --> 00:00:34,046
ואז אני רוצה להיות מסוגלת להגדיר במדוייק את המיקום בכל פעם שאני קוראת לפונקציה, באותה הדרך שבה השתמשנו ב-()elipse וב-()rect.

8
00:00:34,046 --> 00:00:40,460
בסדר? בגלל שאני רוצה לשים וינסטון כאן, ווינסטון כאן, ווינסטון כאן, ווינסטון כאן,

9
00:00:40,460 --> 00:00:44,623
ואני לא רוצה סתם מקומות רנדומלים בכל פעם שאני קוראת לפונקציה (מפעילה את הפונקציה)

10
00:00:44,623 --> 00:00:53,716
אז בשביל לעשות את זה, צריכים להיות לנו פרמטרים ספציפיים עבור הפונקציה, גם בתוך הגדרת הפונקציה שלנו, פה למעלה,

11
00:00:53,716 --> 00:00:58,032
וגם בקריאה שלנו לפונקציה, כאן למטה, איפה שאנחנו קוראים לפונקציה עצמה.

12
00:00:58,032 --> 00:01:10,764
אז, עבור ()drawWinston, אנחנו רוצים להעביר לה את faceX ואת faceY, ולהשתמש בערכים האלו שאנחנו מעבירים במקום לייצר אותם רנדומלית.

13
00:01:10,764 --> 00:01:15,207
בואו נתחיל על ידי לחשוב מה היינו רוצים להעביר בקריאות לפונקציה כאן למטה.

14
00:01:15,207 --> 00:01:20,071
אנחנו רוצים למקם את ווינסטון מתחת לכל שורה של טקסט, אז אנחנו כנראה רוצים שנקודות ה-x וה-y

15
00:01:20,071 --> 00:01:25,131
של כל וינסטון יהיו קרובות למספרים שהעברנו לפונקציות ה-()text.

16
00:01:25,131 --> 00:01:37,708
אולי, אם ניקח נקודה שנמוכה ב-10 פיקסלים על ציר ה-y. אז אולי, הראשון יהיה 10 ו-30, ואז אולי 200, 230...

17
00:01:37,708 --> 00:01:49,596
10, 230.... 200,230. זה אותו הדבר כמו הקוארדינאטות של הטקסט, אני פשוט מוסיפה 10 לכל נקודה y, כי אני רוצה את זה טיפה נמוך יותר.

18
00:01:49,596 --> 00:02:00,127
אוקיי, אבל וינסטון לא זה. זה בכלל שלא אמרנו לפונקציה שלנו פה למעלה שאנחנו מעבירים לה פרמטרים, אז היא עדיין משתמש בערכים הרנדומלים האלו.

19
00:02:00,127 --> 00:02:04,373
על מנת להגיד לפונקציה, ״הי, אנחנו הולכים לתת לך מידע״,

20
00:02:04,373 --> 00:02:09,208
אנחנו צריכים לתת לפרמטרים האלו שם בתוך הסוגריים האלו.

21
00:02:09,208 --> 00:02:17,378
אז נקרא להם faceX ו-faceY, ונפריד ביניהם באמצעות פסיק, ואנחנו הולכים לקרוא להם ככה בגלל

22
00:02:17,378 --> 00:02:25,462
שאלו הם השמות שכבר השתמשנו בהם בתוך הפונקציה, בסדר? ככה לא נצטרך לשכתב את שאר הקוד שלנו.

23
00:02:25,462 --> 00:02:29,333
אבל עדיין, כלום לא קרה. וינסטון עדיין מפוזר בכל מקום.

24
00:02:29,333 --> 00:02:35,873
ובכן, אם תסתכלו בתחילת הפונקציה שלנו, אנחנו עדיין ״דורסים״ את faceX ו-faceY עם משתנים רנדומליים.

25
00:02:35,873 --> 00:02:39,793
אז, כל מה שאנחנו צריכים לעשות הוא למחוק את השורות האלו...

26
00:02:39,793 --> 00:02:50,333
טה-דה! ועכשיו, faceX ו-faceY מועברים אל תוך הפונקציה, והיא משתמשת בערכים שהעברנו לה כאן.

27
00:02:50,333 --> 00:02:58,787
עכשיו כמו שאתם יכולים לראות, לא בדיוק מיקמתי את וינסטון נכונה, בכלל ששכחתי שהטקסט מקבל את המיקום שלו לפי הפינה השמאלית העליונה,

28
00:02:58,787 --> 00:03:06,773
והפרצוף ממוקם לפי המרכז. אז, אני צריכה לשחק קצת עם המספרים שלי טיפה כאן, נכון?

29
00:03:06,773 --> 00:03:13,238
כנראה, אני צריכה להזיז את נקודה x לא מעט, אני צריכה להזיז את זה ל... אוקיי, נראה לי כאן

30
00:03:13,238 --> 00:03:22,413
נעבור על המספרים, ועכשיו כל מה שאני צריכה לשנות זה את המספרים שאני מעבירה לפונקציה, אני לא צריכה לשנות את ההגדרה של הפונקציה עצמה,

31
00:03:22,413 --> 00:03:28,868
בגלל שהיא תמיד תיקח את הערכים שאנחנו מעבירים לה, בסדר? בדיוק כמו עם הפונקציות ()elipse ו-()rect.

32
00:03:28,868 --> 00:03:33,708
אוקיי, אז סוג של מיקמתי את זה, אבל הבחנתי בזה שוינסטון גדול מדי.

33
00:03:33,708 --> 00:03:35,956
הוא מכסה את עצמו, הוא לא מתאים.

34
00:03:35,956 --> 00:03:45,497
אז, מכיוון ששמתי את כל הקוד שמצייר אותו בפונקציה, אני יכולה לשנות את הגודל של כל הוינסטונים בבת אחת פשוט על ידי שינוי שורת הקוד שמציירת את האליפסה.

35
00:03:45,497 --> 00:03:51,126
אז בואו נגיד שנעשה אותו 190, כן, וינסטון הולך להיות בדיאטה, על 190.

36
00:03:51,126 --> 00:04:01,654
יפה מאוד, אוקיי, אז עכשיו הוא מתאים הרבה יותר ואתם יודעים שאני יכולה להמשיך לשחק עם המספרים עד שהוא ייכנס נכון?

37
00:04:01,654 --> 00:04:09,341
מגניב. אז בואו נעשה סקירה אחרונה על מה הקוד הזה עושה. הוא מגדיר פונקציה בשם ()drawWinston,

38
00:04:09,341 --> 00:04:15,193
והפונקציה הזו מקבלת שני ערכים, והיא קוראת להם faceX ו-faceY,

39
00:04:15,193 --> 00:04:25,165
והערכים האלו בגדול מגיעים בצורה של משתנים בהם אנחנו יכולים להשתמש בכל מקום בפונקציה שלנו, בדיקו כמו השתמשנו במשתנים שהכרזנו עליהם למעלה

40
00:04:25,165 --> 00:04:35,001
ואז אנחנו יכולים לקרוא לפונקציה הזו מתי שאנחנו רוצים אחרי שאני מכריזים עליה, ולהעביר לה ערכים שונים, כך שהיא תשתמש בערכים החדשים האלו בכל ריצה.

41
00:04:35,001 --> 00:04:41,230
אז עכשיו הבנתם כמה פונקציות הן מגניבות. אנחנו יכולים להמציא קוד שיהיה ממש מועיל להשתמש בו שוב,

42
00:04:41,230 --> 00:04:46,910
אבל אנחנו גם יכולים להשתמש בפרמטרים בשביל להגיד ״היי, הנה משהו קטן שאפשר לשנות בקוד הזה, בשביל להתאים אותו״.

43
00:04:46,910 --> 00:04:53,342
זה כמו מתכון. אתם כותבים את ההוראות הכלליות, ואם אתם פתאום מבינים שאתם צריכים להאכיל ארבעה וינסטונים ולא וינסטון אחד,

44
00:04:53,342 --> 00:04:58,205
אז אתם לא צריכים להתחיל הכל מההתחלה, אלא פשוט לשנות את ההוראות המקוריות ולהכפיל הכל פי 4.

45
00:04:58,205 --> 00:05:02,205
אז עכשיו אתם יכולים להתחיל לחשוב על המתכונים בקוד שלכם! יאמי!