WEBVTT

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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