עזרה

Step

כדי לגרום לקוף ללכת ("step") מרחק מסויים אנחנו צריכים לכתוב "step X", כאשר X מייצג את מספר הצעדים שאנחנו רוצים שהקוף יצעד, למשל "step 10".
"step" היא פונקציה: סט של הוראות לביצוע משימה מסויימת. "step 20" זו פקודה אשר מורכבת משם הפונקציה (step) ומארגומנט. הארגומנט כאן זה מספר המייצג את מספר הצעדים שאנחנו רוצים שהקוף יצעד. לדוגמא, ב "step 20", הארגומנט הוא 20.
במקרה הזה המתכנת שתכנן את קודמאנקי חסך לנו עבודה כי הוא כבר הגדיר את ההוראות אשר גורמות לפונקציה "step" לעבוד. בתכנות מקובל להשתמש בפונקציות שמישהו אחר הגדיר.
לחצו כאן לקרוא עוד על איך מגדירים פונקציות.
לחצו על הכפתור "step" כדי לכתוב את המילה "step" בקוד שלכם.

Turn

הפונקציה "turn" (סיבוב) צריכה לבוא עם כיוון (שמאל/ימין left/right) או מעלות (45, 90, 180).
לדגומא: "turn right", "turn 90".
"turn" היא פונקציה: סט של הוראות לביצוע משימה מסויימת. "turn left" או "turn 45" הן פקודות אשר מורכבות משם הפונקציה (turn) ומארגומנט. הארגומנט של "turn" הוא כיוון ("left" או "right") או מספר שמייצג מעלות (45, 90, 180). לדוגמא, בפקודה "turn left", הארגומנט הוא "left" (שמאל).
במקרה הזה המתכנת שתכנן את קודמאנקי חסך לנו עבודה כי הוא כבר הגדיר את ההוראות אשר גורמות לפונקציה "turn" לעבוד. בתכנות מקובל להשתמש בפונקציות שמישהו אחר הגדיר.
לחצו כאן לקרוא עוד על איך מגדירים פונקציות.
לחצו על הכפתור "turn" כדי לכתוב את המילה "turn" בקוד שלכם.

Left / Right

"left" (שמאל) ו "right" (ימין) משמשים כארגומנט לפונקציה "turn" אשר גורמת לקוף להסתובב לכיוון הרצוי.
אם לדייק, אז "left" ו "right" הם קבועים אשר מייצגים את הערכים 90 ו 90- בהתאמה. לכן, "turn left" זה בדיוק כמו "turn 90", ו "turn right" זה בדיוק כמו "turn -90".
לחצו על הכפתורים "left" או "right" כדי לכתוב את המילה "left" או "right" בהתאמה בקוד שלכם.

TurnTo

"turnTo" זו עוד דרך להסתובב, במקום להשתמש בכיוון או מעלות, אנחנו מבקשים שהקוף יסתובב אל אובייקט מסויים, לדוגמא: "turnTo banana".
כאשר משתמשים ב "turnTo" המחשב מזהה שיש עוד אובייקט, חוץ מהקוף האהוב שלנו, וכאשר אנחנו משתמשים בשמו של האובייקט, הוא יודע לאן להסתובב.
אובייקטים הם כל דבר בבמה שאיתו אנחנו יכולים לעשות איזושהי אינטרקציה, כמו שיח, גשר, בננה וצב.
"turnTo" היא פונקציה: סט של הוראות לביצוע משימה מסויימת. "turnTo banana" היא פקודה אשר מורכבת משם הפונקציה (turnTo) ומארגומנט. הארגומנט של "turnTo" הוא האובייקט שאליו אנחנו רוצים שהקוף יסתובב. לדוגמא, בפקודה "turnTo banana", הארגומנט הוא "banana" (בננה).
במקרה הזה המתכנת שתכנן את קודמאנקי חסך לנו עבודה כי הוא כבר הגדיר את ההוראות אשר גורמות לפונקציה "turnTo" לעבוד. בתכנות מקובל להשתמש בפונקציות שמישהו אחר הגדיר.
לחצו כאן לקרוא עוד על איך מגדירים פונקציות.
לחצו על הכפתור "turnTo" כדי לכתוב את המילה "turnTo" בקוד שלכם.

Times Loop

לולאה פשוטה היא רצף של הוראות החוזר על עצמו מספר מסוים של פעמים. הנה דוגמא:

בדוגמא הזו הקוף יחזור על הפעולות "step 5", "turn left" שלוש פעמים. ההוראות שאנחנו כותבים בתוך הלולאה צריכות להיות כתובות מתחתיה עם אינדטציה (על המסך מוצג כארבע נקודות....). כדי להוסיף אינדנטציה לחצו על מקש ה "tab" במקלדת.
תכנות הוא לא רק לכתוב את הפקודות הנכונות בסדר הנכון; זה גם לדעת איך לכתוב קוד קריא, קצר ושקל לתחזק אותו. אז במקום לכתוב:
step 10
turn left
step 10
turn left
step 10
turn left
step 10
turn left

אנחנו יכולים לכתוב:
4.times->
    step 10
    turn left

בשני המקרים יקרה אותו הדבר; אלא שבאפשרות השניה הקוד כתוב כלולאה. המשמעות היא שהפקודות "step 10", "turn left" יחזרו על עצמן ארבע פעמים, ואז הלולאה תסתיים. ברגע שהלולאה מסתיימת, המחשב עובר לפקודה הבאה.
לחצו על הכפתור "times" כדי להכניס את המבנה של לולאת times לקוד שלכם:
"3.times ->"

Variables


השמת משתנים. משתנה הוא כמו יחידת אחסון: אנחנו מאחסנים בו נתונים, ואנחנו משתמשים בו רק כאשר אנחנו צריכים אותו. השמה למשתנה מורכבת ממזהה (identifier), סימן שווה = וערך (value).
X הוא מזהה; זה יכול להיות כל אות או מילה אחרת. המזהה הוא שמו של המשתנה. כאשר אנחנו רוצים להשתמש בערך של המשתנה אנחנו כותבים את שמו, לדוגמא: "step x". בדוגמא הזו אנחנו רוצים שהקוף יצעד מרחק השווה לערך של המשתנה; במקרה הזה, 10.
הפרדה זו של שם וערך מאפשרת לנו להשתמש בשם באופן עצמאי מהמידע שהוא מייצג. אנו יכולים להשתמש ב X בעת כתיבת התכנית, בלי לדעת מה הערך שלו יהיה כאשר ההוראות תבוצענה.
בקודמאנקי משתמשים במשתנים כדי לקרוא לפונקציה עם ערך שאינו קבוע. פונקציה היא סט של הוראות לביצוע משימה מסויימת. לכל פונקציה יש שם וארגומנט. אנחנו יכולים להשתמש במשתנה כארגומנט לפונקציות כמו "step" או "turn", ואפילו למספר הפעמים שלולאת "times" תרוץ.
דוגמא נוספת איך להשתמש במשתנה כארגומנט היא בכתיבת שתי הפקודות:
"x = distanceTo banana"
"step x"
. בדוגמא הזו, המחשב מודד את המרחק בין הקוף לבננה ושומר אותו במשתנה x. בפקודה השנייה המחשב יחליף את המזהה x עם הערך שלו, אשר ישמש כארגומנט לפונקציה "step".
לחצו כאן לקרוא עוד על distanceTo.

Say

כאשר נשתמש ב "say", בועת דיבור תופיע ליד הקוף עם הכיתוב שהכנסנו, לדוגמא:

תגרום לקוף להגיד "Boo!".
אנחנו משתמשים במרכאות ("") מסביב לביטוי שאנחנו רוצים שהקוף יגיד כדי שמחשב יבין שהטקסט שהכנסנו אינו שם של משתנה או פונקציה.
נסו להשתמש ב say כאשר העכבר באזור.
לחצו על כפתור ה "say" כדי לכתוב את המילה "say" בקוד שלכם.

distanceTo

בדרך כלל משתמשים בפונקציה "distanceTo" עם עוד פקודה כמו "step" או "say" ואובייקט. כאשר משתמשים ב "distanceTo" זה כמו לשאול "מהו המרחק לבננה?" התשובה היא מספר, המחושב על ידי המחשב, שמייצג את המרחק.
דוגמא:

המחשב מודד את המרחק בין הקוף לאובייקט (הבננה), ואז ישתמש במספר הזה כדי לבצע מה שהורינו לו, תוך שימוש בערך הנמדד כארגומנט ל "step". זה יחסוך לנו זמן וגם יעזור אם אנחנו לא יודעים מראש את המיקום של האובייקטים.
דרך נוספת להשתמש בפונקציה "distanceTo" היא בעזרת משתנים:
x = distanceTo banana
step x

בדוגמא הזו, המחשב מודד את המרחק בין הקוף לבננה, ואז יחליף את המזהה x עם הערך הנמדד, אשר יהיה הארגומנט לפונקציה "step".
"distanceTo" היא פונקציה: סט של הוראות לביצוע משימה מסויימת. "distanceTo banana" זו פקודה שמורכבת משם הפונקציה (distanceTo) ומארגומנט. הארגומנט של הפונקציה "distanceTo" הוא האובייקט שאנחנו רוצים למדוד את המרחק אליו, כמו בננה או שיח. בדוגמא: "step distanceTo banana", הארגומנט של "distanceTo" הוא בננה, והערך שהתקבל הוא הארגומנט לפונקציה "step".
במקרה הזה המתכנת שתכנן את קודמאנקי חסך לנו עבודה כי הוא כבר הגדיר את ההוראות אשר גורמות לפונקציה "distanceTo" לעבוד. בתכנות מקובל להשתמש בפונקציות שמישהו אחר הגדיר.
לחצו כאן לקרוא עוד על איך מגדירים פונקציות.
לחצו על הכפתור "distanceTo" כדי לכתוב את המילה "distanceTo" בקוד שלכם.

For loop

נשתמש בלולאת for כאשר יש לנו אוסף של אובייקטים ואנחנו רוצים לחזור על פעולה המתייחסת לכל אחד מהם באופן ספציפי. לולאת for תמשיך לפעול עד שהפעולות נעשו על כל האובייקטים במערך (array) שלנו.

לולאת for מתייחסת לשני אובייקטים: משתנה לולאה (loop variable) ומערך. משתנה הלולאה הוא שם שאנחנו מקצים; זה יכול להיות כל שם שאנחנו רוצים, כמו משתנים. נפוץ לקרוא לו באות הראשונה של המערך. המערך הוא אוסף המכיל אובייקטים. למשל, אם יש לנו מערך של שש בננות. כל בננה מקבלת שם משלה, כמו bananas[0[ ולכל הבננות ביחד יש שם אחד, שהוא שמו של המערך, כמו bananas.
כאשר המחשב מריץ לולאת for, הוא מחליף את משתנה הלולאה עם הפריט הראשון במערך. כאשר הוא מסיים עם הראשון, הוא עובר לשני וכך הלאה. הלולאה תעצור רק אחרי שכל הפעולות בוצעו עבור כל הפריטים במערך.
לדוגמא, יש לנו את לולאת ה "for" הבאה:
for b in bananas
....turnTo b
....step distanceTo b

בפעם הראשונה שהלולאה תרוץ, המחשב "יקרא" את זה כך:
....turnTo bananas[0]
....step distanceTo bananas[0]

אחר כך, הוא יתחיל מחדש עם הבננה הבאה:
....turnTo bananas[1]
....step distanceTo bananas[1]

וכך ימשיך עד שהקוף יגיע לכל הבננות.

ההבדל מלולאת times
לולאת times חוזרת על הפקודות מספר מוגדר של פעמים, ובכל פעם מבצעת את אותה הפעולה בדיוק.
לעומת זאת, לולאת for, תואמת את מספר הפריטים במערך, ותעצור רק אחרי שכל הפעולות נעשו עבור כל הפריטים במערך.

איך לקרוא לולאת for
for (זה אומר למחשב שיש כאן לולאת "for")
b (הגדרת משתנה הלולאה)
in (חלק מלולאת ה "for")
bananas (שמו של המערך)
....turnTo b (האות b היא משתנה המערך שמתייחס אל אובייקט במערך)
....step distanceTo b (האות b היא משתנה המערך שמתייחס אל אובייקט במערך)
במקום לכתוב את שם המערך ליד כל פונקציה, אנחנו חייבים להשתמש בשמו של משתנה הלולאה שהגדרנו.

לולאות מקוננות

אנחנו יכולים להשתמש בלולאה בתוך לולאה. הדוגמא שלמעלה לקוחה משלב #70.
לולאה מקוננת היא לולאה בתוך לולאה. כאשר משתמשים בלולאה מקוננת, הפקודות של הלולאה הפנימית חוזרת על עצמן שוב ושוב. עבור כל אלמנט של הלולאה החיצונית, הלולאה הפנימית מבוצעת מתחילתה ועד סופה, ולאחר מכן כל התהליך חוזר על עצמו עבור האלמנט הבא בלולאה החיצונית וכך הלאה.
לחצו על הכפתור "for" כדי לכתוב את הטקסט הזה בקוד שלכם. שימו לב שיש שורת הערה:

Grab()/Drop()

"()grab" ו "()drop" הן פונקציות בלי ארגומנט אשר משתמשים בהן בפרק שלוש לעזור לעכבר לאסוף את הגפרורים.
פונקציה היא סט של הוראות לביצוע משימה מסויימת.
פונקציה בלי ארגומנט מבצעת כמה פעולות, אבל לא מחייבת אותנו להעביר קלט, כלומר אנחנו לא צריכים לכתוב מספר או שם של אובייקט אחרי שם הפונקציה. במקום זה, אנחנו קוראים לפונקציה עם סוגריים ריקים ().
במקרה הזה המתכנת שתכנן את קודמאנקי חסך לנו עבודה כי הוא כבר הגדיר את ההוראות אשר גורמות לפונקציות "grab" ו "drop" לעבוד. בתכנות מקובל להשתמש בפונקציות שמישהו אחר הגדיר.
לחצו כאן כדי לקרוא עוד על איך מגדירים פונקציות.
לחצו על הכפתורים grab או drop כדי לכתוב את המילים "()grab" או "()drop" בקוד שלכם, בהתאמה.

Comment



זאת שורת ההערה בקוד. היא מסומנת עם סמל הסולמית # בהתחלה. המחשב לא מתייחס אל שורה זו כהוראה. הערות משמשות את המתכנתים אשר כותבים וקוראים את הקוד כדי להבין אחד את השני. בקודמאנקי משתמשים בהערות כדי לתת לנו רמזים, הוראות והכוונה.

Function

פונקציה היא סט של הוראות לביצוע משימה מסויימת. המחשב יבצע את הפונקציה רק כאשר אנחנו נקרא לה, כלומר נשתמש בה בקוד שלנו.
פונקציות שמקבלות ארגומנט כתובות כך:
function_name = (argument) ->
מתחת להגדרת הפונקציה נכתוב את הפקודות שאנחנו רוצים שהמחשב יבצע כאשר נקרא לפונקציה.
הנה דוגמא להגדרה של הפונקציה "goto", הפונקציה הזו תגרום לקוף ללכת לעבר האובייקט:

שמה של הפונקציה משמש לזיהוי. מתכנתים נותנים לפונקציה שם שמייצג את מה שהיא עושה, זה עוזר לקוד להיות קריא יותר.
כאשר אנחנו קוראים לפונקציה בקוד שלנו, אנחנו צריכים להצמיד את שם הפונקציה עם שם האובייקט שעליו אנחנו רוצים שהפעולות בתוך הפונקציה יבוצעו, לדוגמא "goto banana" יגרום לקוף ללכת לעבר הבננה. כאשר אנחנו קוראים לפונקציה עם הארגומנט בננה (banana), המחשב מחליף את הארגומנט "t" עם "banana".

בקודמאנקי, כאשר אנחנו מגדירים פונקציה חדשה, כפתור חדש יופיע עם שם הפונקציה.
לחצו על הכפתור "function" כדי להוסיף את הטקסט הזה בקוד שלכם. שימו לב שיש שורת הערה:
function_name = (argument) ->
....# Your code here

Until loop

לולאת until מכילה בלוק של קוד שיחזור על עצמו עד שתנאי מסויים יתמלא. התנאי הזה נקרא תנאי הלולאה. המחשב בודק את התנאי בהתחלה, אם התשובה כוזבת (false), הלולאה תמשיך לפעול. היא תיעצר רק כאשר התשובה תהיה אמת (true).
אם לא נשים לב, אנחנו יכולים לתת ללולאת ה "until" תנאי שלא יתממש מעולם. זה יגרום ללולאה להמשיך לפעול לנצח ואף יכול לגרום לתוכנית לקרוס.

בקודמאנקי אנחנו משתמשים בשני תנאי לולאה: near ו cat.sleeping.
הנה דוגמא לשימוש בלולאת "until" עם תנאי לולאה "near":

לחצו כאן כדי לקרוא עוד על תנאי הלולאה near.

הנה דוגמא לשימוש בלולאת "until" עם תנאי לולאה "cat.sleeping":

לחצו כאן כדי לקרוא עוד על תנאי הלולאה cat.sleeping.

מה ההבדל בין לולאת for ללולאת until?
לולאת for מבצעת סט של פעולות על כל האובייקטים במערך, ואז עוצרת.
לולאת until תמשיך לפעול עד שהתנאי יתממש, ואם לא ניזהר היא יכולה להמשיך לנצח.

לחצו על הכפתור "until" כדי להוסיף את הטקסט הזה בקוד שלכם. שימו לב שיש שורת הערה:
until condition
....# Your code here

Near

Near היא פונקציה, בדרך כלל משתמשים בה כתנאי לולאה עבור לולאת until. הערך שהפונקציה "near" מחזירה יקבע מתי לולאת ה until תעצור.

"near" היא פונקציה: סט של הוראות לביצוע משימה מסויימת. "until near match" היא פקודה אשר מורכבת ממילת המפתח until, הפונקציה (near) וארגומנט. הארגומנט של הפונקציה near הוא האובייקט שאנחנו רוצים שהקוף או העכבר יהיו לידו. בדוגמא, "until near match", הארגומנט הוא "match" (גפרור).
במקרה הזה המתכנת שתכנן את קודמאנקי חסך לנו עבודה כי הוא כבר הגדיר את ההוראות אשר גורמות לפונקציה "near" לעבוד. בתכנות מקובל להשתמש בפונקציות שמישהו אחר הגדיר.
לחצו כאן כדי לקרוא עוד על איך מגידירים פונקציות.
לחצו על הכפתור "near" כדי לכתוב את המילה "near" בקוד שלכם.

Sleeping/wait()

בפרק 3 אנחנו מכירים את החתול, החתול יתקוף את העכבר אם הוא יראה אותו, לכן אנחנו צריכים לחכות עד שהוא יישן. אנחנו עושים זאת על ידי כתיבת "()cat.sleeping", אנחנו צריכים להשתמש ב "cat" ובנקודה (.) כדי שהמחשב ידע שאנחנו מחכים שהחתול יירדם.

הפונקציה "sleeping" היא ללא ארגומנט, ואנחנו יכולים להשתמש בה כתנאי הלולאה.
פונקציה היא סט של הוראות לביצוע משימה מסויימת.
פונקציה בלי ארגומנט מבצעת כמה פעולות, אבל לא מחייבת אותנו להעביר קלט, כלומר אנחנו לא צריכים לכתוב מספר או שם של אובייקט אחרי שם הפונקציה. במקום זה, אנחנו קוראים לפונקציה עם סוגריים ריקים ().
במקרה הזה המתכנת שתכנן את קודמאנקי חסך לנו עבודה כי הוא כבר הגדיר את ההוראות אשר גורמות לפונקציה "sleeping" לעבוד. בתכנות מקובל להשתמש בפונקציות שמישהו אחר הגדיר.
לחצו כאן כדי לקרוא עוד על איך מגדירים פונקציות.

()wait היא גם פונקציה ללא ארגומנט. היא תגרום לקוף לחכות שניה אחת ואז תמשיך להוראה הבאה. בלולאה, ההוראה הבאה תהיה לבדוק אם תנאי הלולאה הוא אמת (true). לפי תנאי הלולאה, המחשב ייצא מהלולאה או יחכה שוב, וכך הלאה. לדוגמא:

שחקו