On kengerus and moving with call far – KenGeruX Code

[Idan Dor]

שלום כולם אני עידן דור מקובצת קנגורו, אני וקבוצתי השתתפנו בקודגורו אקסטרים 9 וסיימנו מקום רביעי, בתחרות עצמה יצאנו בשלב א' מקום חמישי, בשלב ב' מקום שני ובשלב השלישי והגמר בגלל שהקוד שלנו התחיל ל"התפורר" (אני יסביר על זה עוד בהמשך) ולא הצלחנו לא להתגונן מה int 0x87 ששתי קבוצות עשו עלינו סיימנו מקום ~9 בהרצה השלישית ומקום רביעי ושיכלול ובגמר.
אני יתחיל בלהסביר קצת על מקום אבסולוטי בזיכרון ועל ההיגיון של השורד שלנו. המקום שממנו המשחק מריץ את האופקוד הבאה של השורד מחושב כך:
Ip + cs * 0x10= Absolute place in memory
כך שאם לדוגמא:
Ip = 0x1234
Cs = 0x1000
אז המיקום האבסולוטי הוא 0x11234.
מכאן כמובן נובע כי הזירה היא בתחום 0x10000 – 0x1ffff וכל מי שיוצא מתחום זה נהרג על ידי המשחק. דבר שבו השתמשנו הרבה הוא השוויון החשוב הבא:
ip = 0x1234
cs = 0x1000
ip + cs * 0x10 = 0x11234
ip = 0x1224
cs = 0x1001
ip + cs * 0x10 = 0x11234
מה שאומר שניתן לייצג כתובת אבסולוטית על הזירה בהמון דרכים כמו בדוגמא למעלה.

כעת אסביר מעט על פקודת "call far" לכל מי שלא מכיר את הפקודה.
הפקודה בדרך כלל נראית כך:
Call far [bx]
והנה מה שהיא עושה:
1. משנה את המיקום האבסולוטי כאילו לפי הפקודות הבאות:
Mov ip, [bx]
Mov cs, [bx + 2]
שימו לב פקודות אלו לא באמת חוקיות אלה רק מקבילות למה שהפקודה call far עושה.
2. מכניסה ארבעה בתים לתוך המחסנית כאילו לפי הפקודות הבאות:
Push ip
Push cs
שימו לב ששוב פקודות אלו לא באמת חוקיות.
עכשיו אסביר קצת על האסטרטגיה מאחורי קנגורו. הרעיון מאחורי קנגורו הוא להיות מפציץ המשתמש ב "call far" אך גם זז תוך כדי ביעילות הפצצה הגבוהה משתי בתים לאופקוד כמו של שורד מ 2011 הנקרא ממליגה.
כדי להפציץ מהר יותר מהיעילות הגבוהה הזו אנחנו מריצים את הקוד הבא מרבית הזמן:
Movsw
Movsw
Call far [di]
עכשיו כדי שקוד זה יעבוד צריך להתקיים: es:di (המיקום האבסולוטי הבא) הוא המיקום של הקוד הבא שהשורד יכתוב. בנוסף ds:di צריך להצביע לכתובת קפיצה חוקית כפי שהסברתי למעלה. כדי לבצע זאת ישנו בשורד משחק מאוד גדול בשינוי סגמנטים ובתחילת המשחק ובכל קפיצה למעלה השורד מכין מראש כתובות חוקיות של קפיצה. כדי לחסוך שינויים בכתובות אלו וכדי להפוך את השורד ליותר פשוט גם קנגורו1 וגם קנגורו2 רצים מאותו מקום על הזירה ומתנהגים כאילו שהם שתי שורדים שונים.
כפי שציינתי למעלה השורד התחיל ל"התפורר" לפני הגמר, מה שבאמת קרה זה שניסינו לחבר בין כמה גרסאות של קנגורו ולשנות כמה משתנים של הקפיצה וכדומה, אך בגלל המשחק הכל כך גדול עם הסגמנטים יצא שהרבה זמן אנחנו הורגים את עצמנו וסיימנו עם קוד שפשוט מתאבד הרבה פעמים בגלל memory exceptions.
בגלל תיקונים של בעיות כאלו ואחרות נאלצנו לגשת לגמר עם שורד שאינו מוגן מ int 0x87 וסבלנו קשות מזה.
אני קצת יסביר על השיטה שבא השתלטנו על הזומבים ואחר כך ארשום את הקוד של השורד של שלב 3 של התחרות. אני ישים למטה קישור לשורד של שלב 2 שלפי דעתי היא גרסא יותר טובה בדרך כלל, אבל בגלל חולשתו של פוביה למפציצים רנדומלים נאלצנו לעבור לקנגורו שמפציץ רנדומלי.

השיטה שבא השתמשנו כדי להשתלט על זומבים היא שיטה דומה לשיטה של פוביה המכונה משפט השאריות הסיני. קנגורו מתחיל בלהשתלט על שתי זומבים בעזרת int 0x87 ולאחר מיכן הזומבים פותרים את החידה של שאר הזומבים בצורה הבאה, הם מקבלים את השארית של הכתובת מ 0x80 ו 0xff (מכיוון שאלו הם המספרים 128 ו 255 הם לא גבוהים אז השיטה עובדת רק 3/4 מהמקרים) ולאחר מיכן מפציצים את שתי המקומות האפשריים בעזרת int 0x86 עם הפקודה לקפוץ לקוד. לאחר ששתי הזומבים הראשונים משתלטים על שניים נוספים הם מתחילים להפציץ את המפה והם מתים תוך ~4000 אופקודים. בזמן ששתי הזומבים הראשונים מתחילים להפציץ השניים הנוספים פותרים את החידה עם שתי הזומבים שנותרו באותה שיטה ואז גם הם מתחילים להפציץ את הזירה. אותו דבר כמובן עושים גם הזומבים שנותרו.

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

;KenGeruXCannon1:
;A few variables
loop_times = 0x10
jump_length = 0x1dd
sp_modifier = 0xdea6
zombie_location = 0xb8f7
zombie_location_2 = 0xb8f3
zombie_start = ((starting_location*0x10 + 0x2400) and 0xffff) – 0x8000
starting_location = 0x0a00
sp_starting_location = (starting_location – 0x80*loop_times)*0x10
es_starting_location = starting_location + loop_times*0x80 – 0x1f

@FakeStart:
jmp @Start

@Start:

;Taking control over a zombie
push es
push ds
pop es
@ZombieThere:
mov word [zombie_location], ax
mov dx, 0xc0dd
mov cx, zombie_location
mov ax, 0x2688
mov bx, 0x16ff
@ZombieHere:
int 0x87
pop es
mov si, [zombie_location]
add si, @ZombieCode – @FakeStart
mov word [si – @ZombieCode + @ZombieHere], 0xd3ff
mov word [si – @ZombieCode + @ZombieHere – 0x2], si
sub si, @ZombieCode – @ZombieThere
mov [zombie_location_2], si

;Putting the looping code in the extra segment
add si, @KenStart – @ZombieThere
mov di, 0x11e
mov cx, (@KenAfterXorSi – @KenStart)/2
rep movsw

;Changing segments and registers
push es
pop ds
push cs
pop ss
mov sp, sp_starting_location
mov cl, 0x8
mov dx, es_starting_location
mov es, dx

;Changing the 'ax' in the extra segment that we placed there earlier into good addresses
mov di, 0xf8
mov bx, 0x1f0 + 0x1
@FirstAddressLoop:
add [di + bx], di
sub di , cx
jnz @FirstAddressLoop

;Reseting some data and starting loop
mov bp, sp_modifier
mov ax, loop_times
sub bx, 0xe
mov cl, 0x10
mov si, 0xc
mov di, 0x1f0
movsb
call far [di]

;Bombing starts here

;Decides whether to jump up or continue looping
@KenStart:

;Jump up
movsw
mov al, loop_times
movsw
movsw
mov dx, es
movsw
movsw
movsw
movsw
sub dx, jump_length – 0x1f
movsw
movsw
movsw
movsw
or dx, word [0x3fe]
movsw
movsw
movsw
movsw
mov [0x3fa], dx
movsw
movsw
movsw
sub dx, 0x1f
movsw
push dx
movsw
movsw
movsw
movsw
mov dx, [0x3fa]
movsw
movsw
movsw
movsw
movsw
movsw
movsw
movsw
mov si, 0x100
@KenGeLoop:
mov [si + bx], dx
sub si, cx
jnz @KenGeLoop
movsw
nop

;Continue Looping
@KenAfterXorSi:

;The zombie code
@ZombieCode:
mov di, 0xc2dd
mov byte [di + 0x1], 0x80
@SecondPlaceToChange:
mov bp, zombie_start
add byte [bx + 0x2], 0x1
add byte [bx + @SecondPlaceToChange – @ZombieCode + 0x2], 0x24
mov ch, 0x20
mov bl, [di]
mov si, bp
mov ax, 0x16ff
mov byte [di + 0x1], 0xff
mov dx, zombie_location_2
mov bh, 0x0
sub bh, bl
add bx, 0x8
add bh, [di]
mov di, bx
sub bp, 0x8
int 0x86
add di, 0x7e80
push es
pop ss
mov sp, si
push ax
push ax
push ax
int 0x86
std
mov di, bp
mov ax, 0xcccc
mov dx, 0x1
mov word [si], 0xabf3
call si

;KenGeruXCannon2:
;A few variables
loop_times = 0x10
jump_length = 0x1dd
sp_modifier = 0xdea6
zombie_location = 0xb8f5
zombie_location_2 = 0xb8f1
zombie_start = (starting_location*0x10 + 0x2400) and 0xffff
starting_location = 0x1a00
sp_starting_location = (starting_location * 0x10) and 0xffff

@FakeStart:
jmp @Start

@Start:

;Taking control over a zombie
push es
push ds
pop es
@ZombieThere:
mov word [zombie_location], ax
mov dx, 0xc1dd
mov cx, zombie_location
mov ax, 0x2688
mov bx, 0x16ff
@ZombieHere:
int 0x87
pop es
mov si, [zombie_location]
add si, @ZombieCode – @FakeStart
mov word [si – @ZombieCode + @ZombieHere], 0xd3ff
mov word [si – @ZombieCode + @ZombieHere – 0x2], si
sub si, @ZombieCode – @ZombieThere
mov [zombie_location_2], si

;Putting the looping code in the extra segment
add si, @KenAfterXorSi – @ZombieThere
mov cx,(@KenEnd – @KenAfterXorSi)/2
rep movsw

;Bombarding the extra segment with the commands 'movsw call far [di] movsw' with int 0x86
mov ax, 0xa5a5
mov dx , 0x1dff
int 0x86

;Putting the jumping code in the extra segment
sub di, 0x4
sub si, @KenEnd – @KenStart
mov cl, (@KenAfterXorSi – @KenStart)/2
rep movsw

;Bombarding the extra segment with our segment and ax with int 0x86
push es
pop ds
mov byte [0x3ff], 0x10
mov di, 0x1f0 + 0x1
mov dx, starting_location
xor ax, ax
int 0x86

;Changing segments and registers
sub dx, 0x1f
mov es, dx
push cs
pop ss
add dx, 0x1f
mov sp , dx
shl sp, cl
mov cl, 0x8

;Changing the 'ax' in the extra segment that we placed there earlier into good addresses
mov di, 0xf8
mov bx, 0xc + 0x2
@FirstAddressLoop:
mov word [di + bx], 0xec29
sub di , cx
jnc @FirstAddressLoop

;Reseting some data and starting loop
mov bp, sp_modifier
mov ax, loop_times
mov bx, 0x1eb
mov cl, 0x10
mov si, @KenEnd – @KenAfterXorSi
mov di, 0x1f0
movsb
call far [di]

;Bombing starts here

;Decides whether to jump up or continue looping
@KenStart:
movsw
dec ax
movsw
push es
movsw
movsw
movsw
movsw
jz @JumpingAfterSi
xor si, si
@JumpingAfterSi:
movsw

;Jump up
movsw
movsw
movsw
movsw
sub sp, ((jump_length*0x10 – loop_times*(0x80 + 0x20*sp_modifier) – 0x2) and 0xffff)
movsw

;Continue Looping
@KenAfterXorSi:
movsw
movsw
movsw
movsw
movsw
pop es
mov di, 0x1f0
movsb
call far [di]
@KenEnd:

;The zombie code
@ZombieCode:
mov di, 0xc4dd
mov byte [di + 0x1], 0x80
@SecondPlaceToChange:
mov bp, zombie_start
add byte [bx + 0x2], 0x1
add byte [bx + @SecondPlaceToChange – @ZombieCode + 0x2], 0x24
mov ch, 0x20
mov bl, [di]
mov si, bp
mov ax, 0x16ff
mov byte [di + 0x1], 0xff
mov dx, zombie_location_2
mov bh, 0x0
sub bh, bl
add bx, 0x8
add bh, [di]
mov di, bx
sub bp, 0x8
int 0x86
add di, 0x7e80
push es
pop ss
mov sp, si
push ax
push ax
push ax
int 0x86
std
mov di, bp
mov ax, 0xcccc
mov dx, 0x1
mov word [si], 0xabf3
call si

הנה הקישור:
https://docs.google.com/document/d/1JORsNxNOf8MIH0lMNKIVT7lCVZClsRy-NmYa8lyEedI/pub

[Idan Dor]

אשמח לענות על כל שאלות שיש לכם

[ddt]

איך מתגוננים מה int 0x87? מישהו יכול לפרסם דוגמה של שורד שמתקיף עם int 0x87 ושורד אחר שמתגונן מההתקפה שלו ושניהם רצים ביחד

"Ip + cs * 0x10= Absolute place in memory "

איפה בקוד של המנוע יש את קטע הקוד שעושה את זה?

אפשר להסביר מה זה "יעילות הפצצה" או מה זה שורד יותר יעיל או יותר מהיר?

למה לפעמים משתמשים בשני movsw ביחד, לפעמים יש 4 movsw אחד אחרי השני ולפעמים יש אפילו 8 כאלו?

אם "גם קנגורו1 וגם קנגורו2 רצים מאותו מקום על הזירה" זה לא בעייתי בשבילכם כי אם מישהו יפגע במקום הזה אז שני השורדים שלכם ימותו בבת אחת נכון?

מה זה אומר ששורד מתחיל ל"התפורר"?

למה בכלל אני ארצה לכתוב שורד או קוד שמתאבד? זה לא לאבד את השורד שלי בלי שאחרים יפגעו בו? מה היתרונות של זה? מתי אני ארצה להשתמש בזה?

איך אני יכול להשתלט על זומבי? מישהו יכול להביא דוגמה לזומבי הכי פשוט ולתוכנית הכי פשוטה שמשתלטת על הזומבי?

מה זה מפציץ רנדומלי? למה השורד בשם פוביה יש לו חולשה למפציפים רנדומליים? איך אני מזהה שורד שיש לו חולשה למפציצים רנדומליים או בכלל איך מזהים חולשות של שורד?

האם יש דוגמה הכי פשוטה לשורד של מפציץ רנדומלי?

"השיטה שבא השתמשנו כדי להשתלט על זומבים היא שיטה דומה לשיטה של פוביה המכונה משפט השאריות הסיני"

יש כמה שיטות להשתלט על זומבים או על הזומבים האלו? מה ההבדל בין השיטה של קנגרו לשיטה של פוביה?

מה זה השיטה של משפט השאריות הסיני? מתי אני צריך להשתמש בה?

לא משתלטים על כל הזומבים בבת אחת? האם צריך להשתלט על זומבי ואז על זומבי אחר?

"אז השיטה עובדת רק 3/4 מהמקרים"
מתי היא לא עובדת? מתי היא כן עובדת?

האם אפשר לראות את הקוד של האסמבלי שיצר את הזומבים? איך הוא שונה מהייצוג שלהם ב disassembly? האם זה אחד לאחד?

האם מישהו יכול לכתוב דוגמה של קוד של זומבי? או את הקוד שיצר את הזומבים שיש בתחרות?

ראיתי שיש לך בשורד של את הקוד של הזומבי – ;The zombie code
איך השגת את הקוד של הזומבי כדי לשים אותו בתוך השורד שלך?
למה בכלל לשים את הקוד של הזומבי בתוך הקוד של השורד? הרי אתה יכול להריץ רק שורד אחד אז למה לשים קוד של זומבי ולא קוד שלך?

מתי אתה תגרום לקוד שלך לעבוד ומתי לקוד של הזומבי בתוך הקוד שלך לעבוד?

מה זה ה extra segment?

[Idan Dor]

אוקיי זה הרבה שאלות אני מקווה שאני יפספס כלום.
הגנה הכי יעילה מ 87 זה להעתיק את הקוד שלך שלוש פעמים ולקפוץ בתחילת הקוד לתוך הקוד האמצעי ככה ה 87 יפגע בחיקויי קוד שלך.
לגבי תקיפה בעזרת 87 יש לי בקוד תקיפה משוג זה כך שאני תוקף שתי זומבים ואומר להם לקפוץ אל הקוד שלי.
אני לא יודע איפה בקוד של המנוע זה רשום אבל ככה זה עובד במעבד האמיתי וזה גם נכון במנוע.
מספר ה
movsw
שיש ברצף מתאים לאורך הפקודה/פקודות שאני מריץ אני ממליץ לך לקרוא על מה הפקודה movsw עושה.
נכון שזה שהם רצים מאותו מקום מהזירה אומר שאם הם מתים הם מתים ביחד אבל בגלל שהם רצים מאותו מקום אז יש להם רק 50% סיכוי להיפגע מהפצצה ולכן בסופו של דבר זה לא משנה.
כשרשמתי "מתפורר" התכוונתי שהקוד התחיל למות באופן באופן עיקבי כשיניתי קבועים נגד כלום, זה בגלל המשחק הכל כך גדול שיש בו עם סגמנטים, יותר מדי קל לנסות לגשת למקום בזיכרון שאין לי גישה אליו ולמות.
אתה אף פעם לא רוצה מפציץ שמתאבד זה לא תכונה זה בעיות בקוד ובקונכפס של השורד הזה, כנראה אפשר לכתוב גרסא יותר יציבה של השורד הזה אבל אני לא בטוח.
הזומבים הם תמיד חידה מתמטית או במדעי המחשב במקרה הזה החידה הייתה קשורה בשאריות אז אני ממליץ לך לקרוא את הקוד של הזומבים של השנה ולהבין את האלגוריתם שלי או של פוביה לפתור את חידתם.
מפציץ רנדומלי הוא מפציץ שבמקום להפציץ שורות שורות הוא מפציץ יותר לאט אבל במקומות "רנדומלי" שהם לא באמת רנדומלים, דוגמא הכי טובה לזה היא השורד שניצח את התחרות השנה תריץ את השורד שלו ותסתכל על מה הוא עושה.
לקוד יש גודל ממוצע- זה הגודל שאם יפגיעו בו אתה תמות, עכשיו בגלל איך שהשורד פוביה בנוי הוא מרבית הזמן עושה המון בדיקות שהם מאוד גדולות בזיכרון והוא לא כותב את עצמו מחדש יותר מידי, ולכן פגיעה רנדומלית בקוד הארוך והפגיעה שלו תהרוג אותו. לגבי איץ מזהים את זה או הבנת הקוד שלו או הרצה והתבוננות בעזרת דיבאגר.
דוגמא פשוטה אני די בטוח שיש אחד כזה איפשהו אבל אני לא לגמרי בטוח.
שנינו השתמשנו בשיטה זהה אני פשוט בחרתי מספרים לשארית שהם קצת מעפנים ולא הבנתי בדיוק את הבעיה בהם אז להם זה עובד ב 500/501 פעמים כזה, אני ממליץ לך לקרוא את הקוד שלהם.
לגבי שאלה זה אני ממליץ לך לקרוא את הקוד של הזומבים.
את צריך לשתמש במשפט זה רק במקרים של שאריות מה שאומר שכנראה לא בזמן הקרוב כי הזומבים משתנים.
זה קצת מסובך לגבי מתי זה עובד ומתי לא אבל זה עובד כאשר
ax = address
al + ah < 0xff
זה קשור במספרים שאני משתמש בהם במשפט השאריות הסיני לפוביה גם יש את הבעיה הזאת אבל אצלם היא הרבה פחות רצינית.
את הקוד של הזומבי יש לכולם והוא משתנה כל שנה.
החלק של הקוד שלי שרשום עליו the zombie code
זה לא באמת הקוד שהזומבי אלה זה הקוד שאני גורם לזומבי שהשתלטתי עליו בעזרת 87 להריץ, בקוד הזה אני גורם לזומבים שלי להפציץ את המפה למות אחרי קצת זמן.
זה רווחי לשים את הקוד האמיתי של הזומבי בתוך הקוד שלך כדי לחסום לפעמים 87 על הזומבי שאנשים אחרים (לדוגמא אני) עושים כדי להשתלט.
הקוד הזה כרגע עובד הוא פשוט ימות קצת אם אשחק עם המשתנים.
extra segment
זה המקום בזיכרון שהוא פרטי לשתי השורדים שלך נהוג לשמור בו קוד ואז להעתיק אותו לזירה.
אני חושב שלא פיספסתי משהו.

[ddt]

תודה על ההסבר המפורט היו כמה שאלות שהתפספסו

לא משתלטים על כל הזומבים בבת אחת? האם צריך להשתלט על זומבי ואז על זומבי אחר?

האם אפשר לראות את הקוד של האסמבלי שיצר את הזומבים? איך הוא שונה מהייצוג שלהם ב disassembly? האם זה אחד לאחד?

האם מישהו יכול לכתוב דוגמה של קוד של זומבי? או את הקוד שיצר את הזומבים שיש בתחרות?

אפשר להסביר מה זה "יעילות הפצצה" או מה זה שורד יותר יעיל או יותר מהיר?

[Idan Dor]

הסיבה היחידה שלא השתלטתי על כולם באותו הזמן זה כי יותר קל ופשוט להשתלט על אחד כל פעם (עם שתי שורדים – שתי כל פעם) אפשר להשתלט על כולם ביחד אבל זה קצת יותר מסובך ויש סיכון שמישהו יפריע להשתלטות (תלוי במה הזומבי עושה)
לגבי קוד זומבי לדוגמא, הנה הקוד של הזומבים של השנה
push cs
pop es
int 0x87
and ax,0x7fff @LoopStart:
push ax
mov bl,[0xc0de]
test bl,bl
jns @AlmostEndLoop
div bl
mov [0xc0dd],ah @AlmostEndLoop:
pop ax
jmp @LoopStart

ההבדל היחדי בין ששת הזומבים הוא ש
0xc0dd and 0xc0de
changed to
0xc1dd and 0xc1de
and to 0xc2dd and 0xc2de
…
and to 0xc5dd and 0xc5de

למקרה שאתה שואל ה 87 הוא כדי לדאוג שלא תוכל להשתמש בזומבים כדי להפציץ חכם אחרים.
לגבי יעילות הפצצה- יעילות הפצצה היא כמות הבתים שאתה פוגע בהם בממוצע לאופקוד, לשורדים טובים יש בדרך כלל 1.9 ממוצע בתים לאופקוד ובעזרת בנית שורדים מסוג אחר אז אפשר להגיע עד ל-4 בתים לאופקוד.
(לפני שאתה שואל- לדרך ההפצצה קוראים call far)
שורד הוא יעיל ככל שהוא מפציץ יותר בממצוע, ושורד הוא פחות פגיע ככל שיש לו פחות בתים שאפשר אם פוגעים בהם להרוג אותו.

[ddt]

לא הבנתי למה אם יש לזומבי הזה את ה INT87
אז אני לא יכול להשתמש בו כדי להפציץ חכם אחרים
הפקודה הזאת היא פקודה התקפית אז למה היא מונעת התקפה ממישהו אחר
צריך פקודה של הגנה או משהו כזה

ואם אפשר גם להסביר כמה שאפשר האם יש קשר בין הזומבים
ואיך יש משהו הם עושים עם שאריות
איך רואים את זה בהרצה
כלומר איך מגיעה כאן שארית

והאם זה משנה איזה שניים אתה משתלט או שזה שתיים כלשהם

תוך כמה זמן אפשר להשתלט עליהם

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

איך נראה קטע קוד שמשתלט על הקוד של הזומבי שאתה הראית
בלי כל שאר התוכנית
רק הפקודות שמשתלטות על מה שהראית
אני רוצה להריץ ביחד ולהבין את זה

תודה כמובן על כל העזרה

[Idan Dor]

הזומבי מבזבז את ה 87 שלו יותר מהר מאשר שאפשר להשתלט עליו ולכל שורד 87 בודד אז הזומבי שאתה משתלט עליהם הם בלי 87.
אפשר בערך תוך כזה 15-30 אופקודים להשתלט עליהם בערך לא באמת ספרתי.
במקרה שלי זה כן משנה על איזה מהם אני משתלט כי אני רוצה שהם יהיו מיד לפני הזומבים הבאים שהם משתלטים עליהם כדי שיהיה יותר סיכוי שאני יקבל את הזומבים ולא מישהו אחר.
כולם יכולים לנסות להשתלט על איזה זומבים שהם רוצים ואם כולם מנסים בבת אחת אז או שאחד מהם מקבל אותו או שאף אחד מהם מקבל את הזומבים בגלל שהם עלולים להפריע אחד לשני.
אם אתה רוצה קוד שמשתלט עליהם פשוט תריץ את הקוד של פוביה ההתחלה שלו עושה בדיוק את מה שאתה מבקש והוא עושה אותה שש פעמים פעם לכל זומבי.

[מאת]

תגובות