0:00:00.877,0:00:06.001
חזרנו לתוכנה שלנו שמציירת את וינסטון, אבל הוספתי לה קצת טקסט.

0:00:06.001,0:00:11.072
רואים, מה שאני רוצה לעשות זה למקם את וינסטון מתחת לכל אחת מהתוויות האלו,

0:00:11.072,0:00:13.210
על מנת להראות אותו בכל נקודה בחיים שלו.

0:00:13.210,0:00:15.197
אבל כרגע הוא מפוזר בכל מקום.

0:00:15.197,0:00:20.449
זה בגלל שהגדרנו את faceX ו-faceY לערכים רנדומלים בתוך הפונקציה הזו.

0:00:20.449,0:00:26.714
בקמום, מה שאנחנו רוצים להגיד לתוכנה זה ״היי, הנה כמה מיקומים מדוייקים שבהם אני רוצה שתציירי את וינסטון״

0:00:26.714,0:00:34.046
ואז אני רוצה להיות מסוגלת להגדיר במדוייק את המיקום בכל פעם שאני קוראת לפונקציה, באותה הדרך שבה השתמשנו ב-()elipse וב-()rect.

0:00:34.046,0:00:40.460
בסדר? בגלל שאני רוצה לשים וינסטון כאן, ווינסטון כאן, ווינסטון כאן, ווינסטון כאן,

0:00:40.460,0:00:44.623
ואני לא רוצה סתם מקומות רנדומלים בכל פעם שאני קוראת לפונקציה (מפעילה את הפונקציה)

0:00:44.623,0:00:53.716
אז בשביל לעשות את זה, צריכים להיות לנו פרמטרים ספציפיים עבור הפונקציה, גם בתוך הגדרת הפונקציה שלנו, פה למעלה,

0:00:53.716,0:00:58.032
וגם בקריאה שלנו לפונקציה, כאן למטה, איפה שאנחנו קוראים לפונקציה עצמה.

0:00:58.032,0:01:10.764
אז, עבור ()drawWinston, אנחנו רוצים להעביר לה את faceX ואת faceY, ולהשתמש בערכים האלו שאנחנו מעבירים במקום לייצר אותם רנדומלית.

0:01:10.764,0:01:15.207
בואו נתחיל על ידי לחשוב מה היינו רוצים להעביר בקריאות לפונקציה כאן למטה.

0:01:15.207,0:01:20.071
אנחנו רוצים למקם את ווינסטון מתחת לכל שורה של טקסט, אז אנחנו כנראה רוצים שנקודות ה-x וה-y

0:01:20.071,0:01:25.131
של כל וינסטון יהיו קרובות למספרים שהעברנו לפונקציות ה-()text.

0:01:25.131,0:01:37.708
אולי, אם ניקח נקודה שנמוכה ב-10 פיקסלים על ציר ה-y. אז אולי, הראשון יהיה 10 ו-30, ואז אולי 200, 230...

0:01:37.708,0:01:49.596
10, 230.... 200,230. זה אותו הדבר כמו הקוארדינאטות של הטקסט, אני פשוט מוסיפה 10 לכל נקודה y, כי אני רוצה את זה טיפה נמוך יותר.

0:01:49.596,0:02:00.127
אוקיי, אבל וינסטון לא זה. זה בכלל שלא אמרנו לפונקציה שלנו פה למעלה שאנחנו מעבירים לה פרמטרים, אז היא עדיין משתמש בערכים הרנדומלים האלו.

0:02:00.127,0:02:04.373
על מנת להגיד לפונקציה, ״הי, אנחנו הולכים לתת לך מידע״,

0:02:04.373,0:02:09.208
אנחנו צריכים לתת לפרמטרים האלו שם בתוך הסוגריים האלו.

0:02:09.208,0:02:17.378
אז נקרא להם faceX ו-faceY, ונפריד ביניהם באמצעות פסיק, ואנחנו הולכים לקרוא להם ככה בגלל

0:02:17.378,0:02:25.462
שאלו הם השמות שכבר השתמשנו בהם בתוך הפונקציה, בסדר? ככה לא נצטרך לשכתב את שאר הקוד שלנו.

0:02:25.462,0:02:29.333
אבל עדיין, כלום לא קרה. וינסטון עדיין מפוזר בכל מקום.

0:02:29.333,0:02:35.873
ובכן, אם תסתכלו בתחילת הפונקציה שלנו, אנחנו עדיין ״דורסים״ את faceX ו-faceY עם משתנים רנדומליים.

0:02:35.873,0:02:39.793
אז, כל מה שאנחנו צריכים לעשות הוא למחוק את השורות האלו...

0:02:39.793,0:02:50.333
טה-דה! ועכשיו, faceX ו-faceY מועברים אל תוך הפונקציה, והיא משתמשת בערכים שהעברנו לה כאן.

0:02:50.333,0:02:58.787
עכשיו כמו שאתם יכולים לראות, לא בדיוק מיקמתי את וינסטון נכונה, בכלל ששכחתי שהטקסט מקבל את המיקום שלו לפי הפינה השמאלית העליונה,

0:02:58.787,0:03:06.773
והפרצוף ממוקם לפי המרכז. אז, אני צריכה לשחק קצת עם המספרים שלי טיפה כאן, נכון?

0:03:06.773,0:03:13.238
כנראה, אני צריכה להזיז את נקודה x לא מעט, אני צריכה להזיז את זה ל... אוקיי, נראה לי כאן

0:03:13.238,0:03:22.413
נעבור על המספרים, ועכשיו כל מה שאני צריכה לשנות זה את המספרים שאני מעבירה לפונקציה, אני לא צריכה לשנות את ההגדרה של הפונקציה עצמה,

0:03:22.413,0:03:28.868
בגלל שהיא תמיד תיקח את הערכים שאנחנו מעבירים לה, בסדר? בדיוק כמו עם הפונקציות ()elipse ו-()rect.

0:03:28.868,0:03:33.708
אוקיי, אז סוג של מיקמתי את זה, אבל הבחנתי בזה שוינסטון גדול מדי.

0:03:33.708,0:03:35.956
הוא מכסה את עצמו, הוא לא מתאים.

0:03:35.956,0:03:45.497
אז, מכיוון ששמתי את כל הקוד שמצייר אותו בפונקציה, אני יכולה לשנות את הגודל של כל הוינסטונים בבת אחת פשוט על ידי שינוי שורת הקוד שמציירת את האליפסה.

0:03:45.497,0:03:51.126
אז בואו נגיד שנעשה אותו 190, כן, וינסטון הולך להיות בדיאטה, על 190.

0:03:51.126,0:04:01.654
יפה מאוד, אוקיי, אז עכשיו הוא מתאים הרבה יותר ואתם יודעים שאני יכולה להמשיך לשחק עם המספרים עד שהוא ייכנס נכון?

0:04:01.654,0:04:09.341
מגניב. אז בואו נעשה סקירה אחרונה על מה הקוד הזה עושה. הוא מגדיר פונקציה בשם ()drawWinston,

0:04:09.341,0:04:15.193
והפונקציה הזו מקבלת שני ערכים, והיא קוראת להם faceX ו-faceY,

0:04:15.193,0:04:25.165
והערכים האלו בגדול מגיעים בצורה של משתנים בהם אנחנו יכולים להשתמש בכל מקום בפונקציה שלנו, בדיקו כמו השתמשנו במשתנים שהכרזנו עליהם למעלה

0:04:25.165,0:04:35.001
ואז אנחנו יכולים לקרוא לפונקציה הזו מתי שאנחנו רוצים אחרי שאני מכריזים עליה, ולהעביר לה ערכים שונים, כך שהיא תשתמש בערכים החדשים האלו בכל ריצה.

0:04:35.001,0:04:41.230
אז עכשיו הבנתם כמה פונקציות הן מגניבות. אנחנו יכולים להמציא קוד שיהיה ממש מועיל להשתמש בו שוב,

0:04:41.230,0:04:46.910
אבל אנחנו גם יכולים להשתמש בפרמטרים בשביל להגיד ״היי, הנה משהו קטן שאפשר לשנות בקוד הזה, בשביל להתאים אותו״.

0:04:46.910,0:04:53.342
זה כמו מתכון. אתם כותבים את ההוראות הכלליות, ואם אתם פתאום מבינים שאתם צריכים להאכיל ארבעה וינסטונים ולא וינסטון אחד,

0:04:53.342,0:04:58.205
אז אתם לא צריכים להתחיל הכל מההתחלה, אלא פשוט לשנות את ההוראות המקוריות ולהכפיל הכל פי 4.

0:04:58.205,0:05:02.205
אז עכשיו אתם יכולים להתחיל לחשוב על המתכונים בקוד שלכם! יאמי!