Deltarune (Chapter 4) script viewer

← back to main script listing

gml_Object_obj_rotating_tower_controller_old_Other_24

(view raw script w/o annotations or w/e)
1 
var render_ypos = (494 - (round(yoffset / 40) - 12)) + round((obj_mainchara.y - 220) / 40);
2 
var render_ypos_start = render_ypos - 14;
3 
var render_ypos_end = render_ypos + 9;
4 
if (render_ypos_end > 500)
5 
    render_ypos_end = 500;
6 
if (renderalt == true)
7 
    render_ypos_start = render_ypos - 7;
8 
if (shake_timer > 0)
9 
{
10 
    if (shake_timer == 30)
11 
    {
12 
        instance_create(x, y, obj_shake);
13 
        snd_play(snd_screenshake);
14 
    }
15 
    if (shake_count == -1)
16 
    {
17 
        render_ypos_start_shake = render_ypos - 16;
18 
        render_ypos_end_shake = render_ypos + 16;
19 
        if (render_ypos_end_shake > 499)
20 
            render_ypos_end_shake = 499;
21 
        shake_count = render_ypos_end_shake + 1;
22 
    }
23 
    shake_timer--;
24 
    if (shake_count > render_ypos_start_shake)
25 
        shake_count--;
26 
    for (var i = render_ypos_end_shake; i > shake_count; i--)
27 
    {
28 
        tower_siner[i] += 5;
29 
        tower_xoffset[i] = sin((100 - tower_siner[i]) / 6) * 14;
30 
        if (render_ypos == i)
31 
            obj_mainchara.tower_shake_xoffset = sin((100 - tower_siner[i]) / 6) * 14;
32 
    }
33 
}
34 
else
35 
{
36 
    shake_timer--;
37 
    if (shake_timer > -20)
38 
    {
39 
        for (var i = render_ypos_start_shake; i < render_ypos_end_shake; i++)
40 
        {
41 
            tower_siner[i] = 0;
42 
            tower_xoffset[i] = lerp(tower_xoffset[i], 0, 0.4);
43 
            obj_mainchara.tower_shake_xoffset = lerp(obj_mainchara.tower_shake_xoffset, 0, 0.4);
44 
        }
45 
    }
46 
    if (shake_timer == -20)
47 
    {
48 
        render_ypos_start_shake = 0;
49 
        render_ypos_end_shake = 0;
50 
        shake_count = -1;
51 
    }
52 
}
53 
if (tower_falls_apart_con == 1)
54 
{
55 
    tower_falls_apart_timer++;
56 
    if (tower_falls_apart_timer == 1)
57 
    {
58 
        if (tower_falls_apart_i == 0)
59 
        {
60 
            tower_falls_apart_i = render_ypos + 6;
61 
            if (tower_falls_apart_i > 499)
62 
                render_ypos_end_shake = 499;
63 
            var i = render_ypos + 7;
64 
            while (i < 499)
65 
            {
66 
                tower_piece_sprite[i] = 4168;
67 
                for (var _i = 0; _i < 8; _i++)
68 
                    tower_object[i][_i] = 0;
69 
                i++;
70 
            }
71 
            tower_object[i][7] = 0;
72 
        }
73 
        else
74 
        {
75 
            tower_falls_apart_i--;
76 
        }
77 
        for (var _i = 0; _i < 8; _i++)
78 
        {
79 
            if (tower_object[tower_falls_apart_i][_i] > 0)
80 
            {
81 
                inst1 = instance_create_depth(x, y, depth + 1, obj_tower_falling_piece_object);
82 
                if (tower_object[tower_falls_apart_i][_i] == 1)
83 
                    inst1.sprite_index = spr_tower_rotating_ladder;
84 
                if (tower_object[tower_falls_apart_i][_i] == 2)
85 
                    inst1.sprite_index = spr_tower_rotating_steps;
86 
                if (tower_object[tower_falls_apart_i][_i] == 3)
87 
                    inst1.sprite_index = spr_tower_rotating_rocks;
88 
                if (tower_object[tower_falls_apart_i][_i] == 4)
89 
                    inst1.sprite_index = spr_tower_rotating_eye;
90 
                if (tower_object[tower_falls_apart_i][_i] == 5)
91 
                    inst1.sprite_index = spr_tower_rotating_eye_drip;
92 
                inst1.i = tower_falls_apart_i;
93 
                inst1.ii = _i;
94 
            }
95 
        }
96 
        inst1 = instance_create_depth(320, ((40 * tower_falls_apart_i) + yoffset) - (towerpiececount * 40), depth + 1, obj_tower_falling_piece);
97 
        inst1.sprite_index = spr_tower_rotating_piece1_strip1;
98 
        inst1.i = tower_falls_apart_i;
99 
        inst2 = instance_create_depth(320, ((40 * tower_falls_apart_i) + yoffset) - (towerpiececount * 40), depth + 1, obj_tower_falling_piece);
100 
        inst2.sprite_index = spr_tower_rotating_piece1_strip2;
101 
        inst2.i = tower_falls_apart_i;
102 
        inst3 = instance_create_depth(320, ((40 * tower_falls_apart_i) + yoffset) - (towerpiececount * 40), depth + 1, obj_tower_falling_piece);
103 
        inst3.sprite_index = spr_tower_rotating_piece1_strip3;
104 
        inst3.i = tower_falls_apart_i;
105 
        inst4 = instance_create_depth(320, ((40 * tower_falls_apart_i) + yoffset) - (towerpiececount * 40), depth + 1, obj_tower_falling_piece);
106 
        inst4.sprite_index = spr_tower_rotating_piece1_strip4;
107 
        inst4.i = tower_falls_apart_i;
108 
        var aaa = choose(1, 3, 2, 4);
109 
        if (aaa == 1)
110 
        {
111 
            inst1.delay = 1;
112 
            inst2.delay = 6;
113 
            inst3.delay = 11;
114 
            inst4.delay = 16;
115 
        }
116 
        if (aaa == 2)
117 
        {
118 
            inst1.delay = 16;
119 
            inst2.delay = 11;
120 
            inst3.delay = 6;
121 
            inst4.delay = 1;
122 
        }
123 
        if (aaa == 3)
124 
        {
125 
            inst1.delay = 6;
126 
            inst2.delay = 1;
127 
            inst3.delay = 16;
128 
            inst4.delay = 11;
129 
        }
130 
        if (aaa == 4)
131 
        {
132 
            inst1.delay = 11;
133 
            inst2.delay = 16;
134 
            inst3.delay = 1;
135 
            inst4.delay = 6;
136 
        }
137 
        if (tower_falls_apart_i <= render_ypos && !instance_exists(obj_tower_falling_kris_falls))
138 
        {
139 
            snd_play_pitch(snd_fall, 0.8);
140 
            krisfalls = instance_create_depth(obj_mainchara.x, obj_mainchara.y, obj_mainchara.depth, obj_tower_falling_kris_falls);
141 
            krisfalls.image_index = obj_mainchara.image_index;
142 
            krisfalls.fall_i = tower_falls_apart_i;
143 
        }
144 
        if (i_ex(obj_rotating_tower_controller) && i_ex(obj_tower_dog) && obj_rotating_tower_controller.yoffset > 4900 && obj_tower_dog.fallingoff == false && ((500 - tower_falls_apart_i) * 40) > (abs(obj_tower_dog.draw_y) - 20))
145 
        {
146 
            with (obj_tower_dog)
147 
                fallingoff = true;
148 
        }
149 
    }
150 
    if (tower_falls_apart_i < render_ypos && !instance_exists(obj_tower_falling_kris_falls))
151 
    {
152 
        snd_play_pitch(snd_fall, 0.8);
153 
        krisfalls = instance_create_depth(obj_mainchara.x, obj_mainchara.y, obj_mainchara.depth, obj_tower_falling_kris_falls);
154 
        krisfalls.image_index = obj_mainchara.image_index;
155 
        krisfalls.fall_i = tower_falls_apart_i;
156 
    }
157 
    if (tower_falls_apart_timer == 2)
158 
    {
159 
        tower_piece_sprite[tower_falls_apart_i] = 4168;
160 
        for (var _i = 0; _i < 8; _i++)
161 
            tower_object[tower_falls_apart_i][_i] = tower_object[tower_falls_apart_i][_i] * -1;
162 
    }
163 
    if (!instance_exists(obj_tower_falling_kris_falls) && endclimb == false)
164 
    {
165 
        var fallfast = true;
166 
        if (room == room_dw_church_dogclimb && yoffset > 2800 && yoffset < 4600 && obj_rotating_tower_controller.yoffset < 4900)
167 
            fallfast = false;
168 
        if ((abs(render_ypos - tower_falls_apart_i) > 3 && fallfast && tower_falls_apart_timer == 15) || tower_falls_apart_timer >= 60 || (yoffset >= 4600 && tower_falls_apart_i > 399) || (yoffset >= 4600 && tower_falls_apart_timer == 15))
169 
            tower_falls_apart_timer = 0;
170 
    }
171 
}
172 
if (room == room_dw_church_dogclimb && tower_falls_apart_con == 1)
173 
{
174 
    tower_falls_apart_timer_dog++;
175 
    if (tower_falls_apart_timer_dog == 1)
176 
    {
177 
        if (tower_falls_apart_i_dog == 0)
178 
        {
179 
            tower_falls_apart_i_dog = render_ypos + 6;
180 
            var i = render_ypos + 7;
181 
            while (i < 499)
182 
            {
183 
                tower_piece_sprite_dog[i] = 4168;
184 
                i++;
185 
            }
186 
        }
187 
        else
188 
        {
189 
            tower_falls_apart_i_dog--;
190 
        }
191 
        inst = instance_create_depth(x, y, depth - 1, obj_tower_falling_piece_object);
192 
        inst.sprite_index = spr_tower_rotating_ladder;
193 
        inst.i = tower_falls_apart_i_dog;
194 
        inst.ii = 6;
195 
        inst.dog = true;
196 
        inst5 = instance_create_depth(560, ((40 * tower_falls_apart_i_dog) + yoffset) - (towerpiececount * 40), depth + 1, obj_tower_falling_piece);
197 
        inst5.sprite_index = spr_tower_rotating_piece1_strip1;
198 
        inst5.i = tower_falls_apart_i_dog;
199 
        inst6 = instance_create_depth(560, ((40 * tower_falls_apart_i_dog) + yoffset) - (towerpiececount * 40), depth + 1, obj_tower_falling_piece);
200 
        inst6.sprite_index = spr_tower_rotating_piece1_strip2;
201 
        inst6.i = tower_falls_apart_i_dog;
202 
        inst7 = instance_create_depth(560, ((40 * tower_falls_apart_i_dog) + yoffset) - (towerpiececount * 40), depth + 1, obj_tower_falling_piece);
203 
        inst7.sprite_index = spr_tower_rotating_piece1_strip3;
204 
        inst7.i = tower_falls_apart_i_dog;
205 
        inst8 = instance_create_depth(560, ((40 * tower_falls_apart_i_dog) + yoffset) - (towerpiececount * 40), depth + 1, obj_tower_falling_piece);
206 
        inst8.sprite_index = spr_tower_rotating_piece1_strip4;
207 
        inst8.i = tower_falls_apart_i_dog;
208 
        var aaa = choose(1, 3, 2, 4);
209 
        if (aaa == 1)
210 
        {
211 
            inst5.delay = 16;
212 
            inst6.delay = 11;
213 
            inst7.delay = 6;
214 
            inst8.delay = 1;
215 
        }
216 
        if (aaa == 2)
217 
        {
218 
            inst5.delay = 6;
219 
            inst6.delay = 1;
220 
            inst7.delay = 16;
221 
            inst8.delay = 11;
222 
        }
223 
        if (aaa == 3)
224 
        {
225 
            inst5.delay = 11;
226 
            inst6.delay = 16;
227 
            inst7.delay = 1;
228 
            inst8.delay = 6;
229 
        }
230 
        if (aaa == 4)
231 
        {
232 
            inst5.delay = 1;
233 
            inst6.delay = 6;
234 
            inst7.delay = 11;
235 
            inst8.delay = 16;
236 
        }
237 
        if (i_ex(obj_rotating_tower_controller) && i_ex(obj_tower_dog) && obj_rotating_tower_controller.yoffset > 4900 && obj_tower_dog.fallingoff == false && ((500 - tower_falls_apart_i_dog) * 40) > (abs(obj_tower_dog.draw_y) - 20))
238 
        {
239 
            with (obj_tower_dog)
240 
                fallingoff = true;
241 
        }
242 
    }
243 
    if (i_ex(obj_rotating_tower_controller) && i_ex(obj_tower_dog) && obj_rotating_tower_controller.yoffset > 4900 && obj_tower_dog.fallingoff == false && ((500 - tower_falls_apart_i_dog) * 40) > (abs(obj_tower_dog.draw_y) - 20))
244 
    {
245 
        with (obj_tower_dog)
246 
            fallingoff = true;
247 
    }
248 
    if (tower_falls_apart_timer_dog == 2)
249 
        tower_piece_sprite_dog[tower_falls_apart_i_dog] = 4168;
250 
    if (endclimb == false)
251 
    {
252 
        var fallfast = true;
253 
        if (room == room_dw_church_dogclimb && yoffset > 2800 && yoffset < 4600 && obj_rotating_tower_controller.yoffset < 4900)
254 
            fallfast = false;
255 
        if ((abs(render_ypos - tower_falls_apart_i) > 3 && fallfast && tower_falls_apart_timer_dog == 15) || tower_falls_apart_timer_dog >= 60 || (yoffset >= 4600 && tower_falls_apart_i > 390 && tower_falls_apart_timer_dog == 2) || (yoffset >= 4600 && tower_falls_apart_timer_dog == 5))
256 
            tower_falls_apart_timer_dog = 0;
257 
    }
258 
}
259 
for (var i = render_ypos_start; i < render_ypos_end; i++)
260 
{
261 
    if ((((40 * i) + yoffset) - (towerpiececount * 40)) > -40 || endclimb == false)
262 
    {
263 
        if (tower_image_index == 0)
264 
            tower_image_index = 0;
265 
        draw_sprite(tower_piece_sprite[i], tower_image_index, 320 + tower_xoffset[i], ((40 * i) + yoffset) - (towerpiececount * 40));
266 
        if (tower_piece_sprite[i] != 5316)
267 
            draw_sprite(spr_tower_rotating_fountain_gradient, 0, 320 + tower_xoffset[i], ((40 * i) + yoffset) - (towerpiececount * 40));
268 
        if (room == room_dw_church_dogclimb)
269 
            draw_sprite(tower_piece_sprite_dog[i], tower_image_index, 560 + tower_xoffset[i], ((40 * i) + yoffset) - (towerpiececount * 40));
270 
    }
271 
}
272 
with (obj_tower_falling_piece)
273 
    image_index = obj_rotating_tower_controller.tower_image_index;
274 
var piecemaxdistance = 70;
275 
var piececount = 7;
276 
if (wide_tower)
277 
{
278 
    piecemaxdistance = 110;
279 
    piececount = 9;
280 
}
281 
eyesmoketimer++;
282 
if (tower_type == 0)
283 
{
284 
    for (var i = render_ypos_start; i < render_ypos_end; i++)
285 
    {
286 
        for (var ii = 0; ii < (piececount + 1); ii++)
287 
        {
288 
            piecemaxdistance = 70;
289 
            piececount = 7;
290 
            if (wide_tower)
291 
            {
292 
                piecemaxdistance = 110;
293 
                piececount = 9;
294 
            }
295 
            if (tower_object[i][ii] == 1 || tower_object[i][ii] == 2 || tower_object[i][ii] == 3 || tower_object[i][ii] == 4)
296 
            {
297 
                var ladder_index = 4;
298 
                var xx = 0;
299 
                var vis = false;
300 
                if (tower_object[i][ii] == 3 || tower_object[i][ii] == 4)
301 
                    piecemaxdistance = 100;
302 
                if (wide_tower == false)
303 
                {
304 
                    vis = true;
305 
                    if (ii == 0)
306 
                    {
307 
                        if (tower_angle >= 350 && tower_angle < 357)
308 
                            ladder_index = 0;
309 
                        else if (tower_angle >= 357 || tower_angle < 12)
310 
                            ladder_index = 1;
311 
                        else if (tower_angle >= 12 && tower_angle < 20)
312 
                            ladder_index = 2;
313 
                        else if (tower_angle >= 20 && tower_angle < 65)
314 
                            ladder_index = 3;
315 
                        else if (tower_angle >= 65 && tower_angle < 115)
316 
                            ladder_index = 4;
317 
                        else if (tower_angle >= 115 && tower_angle < 160)
318 
                            ladder_index = 5;
319 
                        else if (tower_angle >= 160 && tower_angle < 168)
320 
                            ladder_index = 6;
321 
                        else if (tower_angle >= 168 && tower_angle < 183)
322 
                            ladder_index = 7;
323 
                        else if (tower_angle >= 183 && tower_angle < 190)
324 
                            ladder_index = 8;
325 
                        else
326 
                            ladder_index = 9;
327 
                        if (tower_angle >= 350)
328 
                            xx = lerp(piecemaxdistance * -1, 0, (tower_angle - 350) / 100);
329 
                        if (tower_angle < 90)
330 
                            xx = lerp(piecemaxdistance * -1, 0, (10 + tower_angle) / 100);
331 
                        if (tower_angle >= 90 && tower_angle < 190)
332 
                            xx = lerp(0, piecemaxdistance, (tower_angle - 90) / 100);
333 
                    }
334 
                    if (ii == 1)
335 
                    {
336 
                        if (tower_angle >= 35 && tower_angle < 42)
337 
                            ladder_index = 0;
338 
                        else if (tower_angle >= 42 && tower_angle < 57)
339 
                            ladder_index = 1;
340 
                        else if (tower_angle >= 57 && tower_angle < 65)
341 
                            ladder_index = 2;
342 
                        else if (tower_angle >= 65 && tower_angle < 110)
343 
                            ladder_index = 3;
344 
                        else if (tower_angle >= 110 && tower_angle < 160)
345 
                            ladder_index = 4;
346 
                        else if (tower_angle >= 160 && tower_angle < 205)
347 
                            ladder_index = 5;
348 
                        else if (tower_angle >= 205 && tower_angle < 213)
349 
                            ladder_index = 6;
350 
                        else if (tower_angle >= 213 && tower_angle < 228)
351 
                            ladder_index = 7;
352 
                        else if (tower_angle >= 228 && tower_angle < 235)
353 
                            ladder_index = 8;
354 
                        else
355 
                            ladder_index = 9;
356 
                        if (tower_angle >= 35 && tower_angle < 135)
357 
                            xx = lerp(piecemaxdistance * -1, 0, (tower_angle - 35) / 100);
358 
                        if (tower_angle >= 135 && tower_angle < 235)
359 
                            xx = lerp(0, piecemaxdistance, (tower_angle - 135) / 100);
360 
                    }
361 
                    if (ii == 2)
362 
                    {
363 
                        if (tower_angle >= 80 && tower_angle < 87)
364 
                            ladder_index = 0;
365 
                        else if (tower_angle >= 87 && tower_angle < 102)
366 
                            ladder_index = 1;
367 
                        else if (tower_angle >= 102 && tower_angle < 110)
368 
                            ladder_index = 2;
369 
                        else if (tower_angle >= 110 && tower_angle < 155)
370 
                            ladder_index = 3;
371 
                        else if (tower_angle >= 155 && tower_angle < 205)
372 
                            ladder_index = 4;
373 
                        else if (tower_angle >= 205 && tower_angle < 250)
374 
                            ladder_index = 5;
375 
                        else if (tower_angle >= 250 && tower_angle < 258)
376 
                            ladder_index = 6;
377 
                        else if (tower_angle >= 258 && tower_angle < 273)
378 
                            ladder_index = 7;
379 
                        else if (tower_angle >= 273 && tower_angle < 280)
380 
                            ladder_index = 8;
381 
                        else
382 
                            ladder_index = 9;
383 
                        if (tower_angle >= 80 && tower_angle < 180)
384 
                            xx = lerp(piecemaxdistance * -1, 0, (tower_angle - 80) / 100);
385 
                        if (tower_angle >= 180 && tower_angle < 280)
386 
                            xx = lerp(0, piecemaxdistance, (tower_angle - 180) / 100);
387 
                    }
388 
                    if (ii == 3)
389 
                    {
390 
                        if (tower_angle >= 125 && tower_angle < 132)
391 
                            ladder_index = 0;
392 
                        else if (tower_angle >= 132 && tower_angle < 147)
393 
                            ladder_index = 1;
394 
                        else if (tower_angle >= 147 && tower_angle < 155)
395 
                            ladder_index = 2;
396 
                        else if (tower_angle >= 155 && tower_angle < 200)
397 
                            ladder_index = 3;
398 
                        else if (tower_angle >= 200 && tower_angle < 250)
399 
                            ladder_index = 4;
400 
                        else if (tower_angle >= 250 && tower_angle < 295)
401 
                            ladder_index = 5;
402 
                        else if (tower_angle >= 295 && tower_angle < 303)
403 
                            ladder_index = 6;
404 
                        else if (tower_angle >= 303 && tower_angle < 318)
405 
                            ladder_index = 7;
406 
                        else if (tower_angle >= 318 && tower_angle < 325)
407 
                            ladder_index = 8;
408 
                        else
409 
                            ladder_index = 9;
410 
                        if (tower_angle >= 125 && tower_angle < 225)
411 
                            xx = lerp(piecemaxdistance * -1, 0, (tower_angle - 125) / 100);
412 
                        if (tower_angle >= 225 && tower_angle < 325)
413 
                            xx = lerp(0, piecemaxdistance, (tower_angle - 225) / 100);
414 
                    }
415 
                    if (ii == 4)
416 
                    {
417 
                        if (tower_angle >= 170 && tower_angle < 177)
418 
                            ladder_index = 0;
419 
                        else if (tower_angle >= 177 && tower_angle < 192)
420 
                            ladder_index = 1;
421 
                        else if (tower_angle >= 192 && tower_angle < 200)
422 
                            ladder_index = 2;
423 
                        else if (tower_angle >= 200 && tower_angle < 245)
424 
                            ladder_index = 3;
425 
                        else if (tower_angle >= 245 && tower_angle < 295)
426 
                            ladder_index = 4;
427 
                        else if (tower_angle >= 295 && tower_angle < 340)
428 
                            ladder_index = 5;
429 
                        else if (tower_angle >= 340 && tower_angle < 348)
430 
                            ladder_index = 6;
431 
                        else if (tower_angle >= 348 || tower_angle < 3)
432 
                            ladder_index = 7;
433 
                        else if (tower_angle >= 3 && tower_angle < 10)
434 
                            ladder_index = 8;
435 
                        else
436 
                            ladder_index = 9;
437 
                        if (tower_angle >= 170 && tower_angle < 270)
438 
                            xx = lerp(piecemaxdistance * -1, 0, (tower_angle - 170) / 100);
439 
                        if (tower_angle >= 270)
440 
                            xx = lerp(0, piecemaxdistance, (tower_angle - 270) / 100);
441 
                        if (tower_angle <= 10)
442 
                            xx = lerp(0, piecemaxdistance, (90 + tower_angle) / 100);
443 
                    }
444 
                    if (ii == 5)
445 
                    {
446 
                        if (tower_angle >= 215 && tower_angle < 222)
447 
                            ladder_index = 0;
448 
                        else if (tower_angle >= 222 && tower_angle < 237)
449 
                            ladder_index = 1;
450 
                        else if (tower_angle >= 237 && tower_angle < 245)
451 
                            ladder_index = 2;
452 
                        else if (tower_angle >= 245 && tower_angle < 290)
453 
                            ladder_index = 3;
454 
                        else if (tower_angle >= 290 && tower_angle < 340)
455 
                            ladder_index = 4;
456 
                        else if (tower_angle >= 340 || tower_angle < 25)
457 
                            ladder_index = 5;
458 
                        else if (tower_angle >= 25 && tower_angle < 33)
459 
                            ladder_index = 6;
460 
                        else if (tower_angle >= 33 && tower_angle < 48)
461 
                            ladder_index = 7;
462 
                        else if (tower_angle >= 48 && tower_angle < 55)
463 
                            ladder_index = 8;
464 
                        else
465 
                            ladder_index = 9;
466 
                        if (tower_angle >= 215 && tower_angle < 315)
467 
                            xx = lerp(piecemaxdistance * -1, 0, (tower_angle - 215) / 100);
468 
                        if (tower_angle >= 315)
469 
                            xx = lerp(0, piecemaxdistance, (tower_angle - 315) / 100);
470 
                        if (tower_angle <= 55)
471 
                            xx = lerp(0, piecemaxdistance, (45 + tower_angle) / 100);
472 
                    }
473 
                    if (ii == 6)
474 
                    {
475 
                        if (tower_angle >= 260 && tower_angle < 266)
476 
                            ladder_index = 0;
477 
                        else if (tower_angle >= 267 && tower_angle < 282)
478 
                            ladder_index = 1;
479 
                        else if (tower_angle >= 282 && tower_angle < 290)
480 
                            ladder_index = 2;
481 
                        else if (tower_angle >= 290 && tower_angle < 335)
482 
                            ladder_index = 3;
483 
                        else if (tower_angle >= 335 || tower_angle < 25)
484 
                            ladder_index = 4;
485 
                        else if (tower_angle >= 25 && tower_angle < 70)
486 
                            ladder_index = 5;
487 
                        else if (tower_angle >= 70 && tower_angle < 78)
488 
                            ladder_index = 6;
489 
                        else if (tower_angle >= 78 && tower_angle < 93)
490 
                            ladder_index = 7;
491 
                        else if (tower_angle >= 93 && tower_angle < 100)
492 
                            ladder_index = 8;
493 
                        else
494 
                            ladder_index = 9;
495 
                        if (tower_angle >= 260)
496 
                            xx = lerp(piecemaxdistance * -1, 0, (tower_angle - 260) / 100);
497 
                        if (tower_angle < 100)
498 
                            xx = lerp(0, piecemaxdistance, tower_angle / 100);
499 
                    }
500 
                    if (ii == 7)
501 
                    {
502 
                        if (tower_angle >= 305 && tower_angle < 312)
503 
                            ladder_index = 0;
504 
                        else if (tower_angle >= 312 && tower_angle < 327)
505 
                            ladder_index = 1;
506 
                        else if (tower_angle >= 327 && tower_angle < 335)
507 
                            ladder_index = 2;
508 
                        else if (tower_angle >= 335 || tower_angle < 20)
509 
                            ladder_index = 3;
510 
                        else if (tower_angle >= 20 && tower_angle < 70)
511 
                            ladder_index = 4;
512 
                        else if (tower_angle >= 70 && tower_angle < 115)
513 
                            ladder_index = 5;
514 
                        else if (tower_angle >= 115 && tower_angle < 123)
515 
                            ladder_index = 6;
516 
                        else if (tower_angle >= 123 && tower_angle < 138)
517 
                            ladder_index = 7;
518 
                        else if (tower_angle >= 138 && tower_angle < 145)
519 
                            ladder_index = 8;
520 
                        else
521 
                            ladder_index = 9;
522 
                        if (tower_angle >= 305)
523 
                            xx = lerp(piecemaxdistance * -1, 0, (tower_angle - 305) / 100);
524 
                        if (tower_angle < 45)
525 
                            xx = lerp(piecemaxdistance * -1, 0, (45 + tower_angle) / 100);
526 
                        if (tower_angle >= 45 && tower_angle < 145)
527 
                            xx = lerp(0, piecemaxdistance, (tower_angle - 45) / 100);
528 
                    }
529 
                }
530 
                if (wide_tower == true)
531 
                {
532 
                    var _tower_angle = tower_angle;
533 
                    var _tower_x_origin = 320 + tower_xoffset[i];
534 
                    if (tower_object[i][ii] == 4 && tower_eyeoffset[i] > 0)
535 
                    {
536 
                        tower_eyeoffset[i]++;
537 
                        if (tower_eyeoffset[i] >= 360)
538 
                            tower_eyeoffset[i] -= 360;
539 
                        _tower_angle = tower_angle + tower_eyeoffset[i];
540 
                        if (_tower_angle >= 360)
541 
                            _tower_angle -= 360;
542 
                    }
543 
                    if (ii == 0)
544 
                    {
545 
                        vis = true;
546 
                        if (_tower_angle >= 350 && _tower_angle < 353)
547 
                            ladder_index = 0;
548 
                        else if (_tower_angle >= 353 || _tower_angle < 6)
549 
                            ladder_index = 1;
550 
                        else if (_tower_angle >= 6 && _tower_angle < 20)
551 
                            ladder_index = 2;
552 
                        else if (_tower_angle >= 20 && _tower_angle < 50)
553 
                            ladder_index = 3;
554 
                        else if (_tower_angle >= 50 && _tower_angle < 130)
555 
                            ladder_index = 4;
556 
                        else if (_tower_angle >= 130 && _tower_angle < 160)
557 
                            ladder_index = 5;
558 
                        else if (_tower_angle >= 160 && _tower_angle < 173)
559 
                            ladder_index = 6;
560 
                        else if (_tower_angle >= 173 && _tower_angle < 187)
561 
                            ladder_index = 7;
562 
                        else if (_tower_angle >= 187 && _tower_angle < 190)
563 
                            ladder_index = 8;
564 
                        else
565 
                            ladder_index = 9;
566 
                        if (_tower_angle >= 350)
567 
                            xx = lerp(piecemaxdistance * -1, 0, (_tower_angle - 350) / 100) + 4;
568 
                        if (_tower_angle < 90)
569 
                            xx = lerp(piecemaxdistance * -1, 0, (10 + _tower_angle) / 100) + 4;
570 
                        if (_tower_angle >= 90 && _tower_angle < 190)
571 
                            xx = lerp(0, piecemaxdistance, (_tower_angle - 90) / 100) + 4;
572 
                        if (_tower_angle > 190 && _tower_angle < 350)
573 
                            vis = false;
574 
                    }
575 
                    if (ii == 1)
576 
                    {
577 
                        vis = true;
578 
                        if (_tower_angle >= 25 && _tower_angle < 28)
579 
                            ladder_index = 0;
580 
                        else if (_tower_angle >= 28 && _tower_angle < 41)
581 
                            ladder_index = 1;
582 
                        else if (_tower_angle >= 41 && _tower_angle < 55)
583 
                            ladder_index = 2;
584 
                        else if (_tower_angle >= 55 && _tower_angle < 85)
585 
                            ladder_index = 3;
586 
                        else if (_tower_angle >= 85 && _tower_angle < 165)
587 
                            ladder_index = 4;
588 
                        else if (_tower_angle >= 165 && _tower_angle < 195)
589 
                            ladder_index = 5;
590 
                        else if (_tower_angle >= 195 && _tower_angle < 209)
591 
                            ladder_index = 6;
592 
                        else if (_tower_angle >= 209 && _tower_angle < 222)
593 
                            ladder_index = 7;
594 
                        else if (_tower_angle >= 222 && _tower_angle < 225)
595 
                            ladder_index = 8;
596 
                        else
597 
                            ladder_index = 9;
598 
                        if (_tower_angle >= 25 && _tower_angle < 125)
599 
                            xx = lerp(piecemaxdistance * -1, 0, (_tower_angle - 25) / 100) + 2;
600 
                        if (_tower_angle >= 125 && _tower_angle < 225)
601 
                            xx = lerp(0, piecemaxdistance, (_tower_angle - 125) / 100) + 2;
602 
                        if (_tower_angle > 225 || _tower_angle < 25)
603 
                            vis = false;
604 
                    }
605 
                    if (ii == 2)
606 
                    {
607 
                        vis = true;
608 
                        if (_tower_angle >= 60 && _tower_angle < 63)
609 
                            ladder_index = 0;
610 
                        else if (_tower_angle >= 63 && _tower_angle < 76)
611 
                            ladder_index = 1;
612 
                        else if (_tower_angle >= 76 && _tower_angle < 90)
613 
                            ladder_index = 2;
614 
                        else if (_tower_angle >= 90 && _tower_angle < 120)
615 
                            ladder_index = 3;
616 
                        else if (_tower_angle >= 120 && _tower_angle < 200)
617 
                            ladder_index = 4;
618 
                        else if (_tower_angle >= 200 && _tower_angle < 230)
619 
                            ladder_index = 5;
620 
                        else if (_tower_angle >= 230 && _tower_angle < 244)
621 
                            ladder_index = 6;
622 
                        else if (_tower_angle >= 244 && _tower_angle < 257)
623 
                            ladder_index = 7;
624 
                        else if (_tower_angle >= 257 && _tower_angle < 260)
625 
                            ladder_index = 8;
626 
                        else
627 
                            ladder_index = 9;
628 
                        if (_tower_angle >= 60 && _tower_angle < 160)
629 
                            xx = lerp(piecemaxdistance * -1, 0, (_tower_angle - 60) / 100);
630 
                        if (_tower_angle >= 160 && _tower_angle < 260)
631 
                            xx = lerp(0, piecemaxdistance, (_tower_angle - 160) / 100);
632 
                        if (_tower_angle > 260 || _tower_angle < 60)
633 
                            vis = false;
634 
                    }
635 
                    if (ii == 3)
636 
                    {
637 
                        vis = true;
638 
                        if (_tower_angle >= 95 && _tower_angle < 98)
639 
                            ladder_index = 0;
640 
                        else if (_tower_angle >= 98 && _tower_angle < 111)
641 
                            ladder_index = 1;
642 
                        else if (_tower_angle >= 111 && _tower_angle < 125)
643 
                            ladder_index = 2;
644 
                        else if (_tower_angle >= 125 && _tower_angle < 155)
645 
                            ladder_index = 3;
646 
                        else if (_tower_angle >= 155 && _tower_angle < 235)
647 
                            ladder_index = 4;
648 
                        else if (_tower_angle >= 235 && _tower_angle < 265)
649 
                            ladder_index = 5;
650 
                        else if (_tower_angle >= 265 && _tower_angle < 279)
651 
                            ladder_index = 6;
652 
                        else if (_tower_angle >= 279 && _tower_angle < 292)
653 
                            ladder_index = 7;
654 
                        else if (_tower_angle >= 292 && _tower_angle < 295)
655 
                            ladder_index = 8;
656 
                        else
657 
                            ladder_index = 9;
658 
                        if (_tower_angle >= 95 && _tower_angle < 195)
659 
                            xx = lerp(piecemaxdistance * -1, 0, (_tower_angle - 95) / 100);
660 
                        if (_tower_angle >= 195 && _tower_angle < 295)
661 
                            xx = lerp(0, piecemaxdistance, (_tower_angle - 195) / 100);
662 
                        if (_tower_angle > 330 || _tower_angle < 130)
663 
                            vis = false;
664 
                    }
665 
                    if (ii == 4)
666 
                    {
667 
                        vis = true;
668 
                        if (_tower_angle >= 130 && _tower_angle < 133)
669 
                            ladder_index = 0;
670 
                        else if (_tower_angle >= 133 && _tower_angle < 146)
671 
                            ladder_index = 1;
672 
                        else if (_tower_angle >= 146 && _tower_angle < 160)
673 
                            ladder_index = 2;
674 
                        else if (_tower_angle >= 160 && _tower_angle < 190)
675 
                            ladder_index = 3;
676 
                        else if (_tower_angle >= 190 && _tower_angle < 270)
677 
                            ladder_index = 4;
678 
                        else if (_tower_angle >= 270 && _tower_angle < 300)
679 
                            ladder_index = 5;
680 
                        else if (_tower_angle >= 300 && _tower_angle < 314)
681 
                            ladder_index = 6;
682 
                        else if (_tower_angle >= 314 && _tower_angle < 327)
683 
                            ladder_index = 7;
684 
                        else if (_tower_angle >= 327 && _tower_angle < 330)
685 
                            ladder_index = 8;
686 
                        else
687 
                            ladder_index = 9;
688 
                        if (_tower_angle >= 130 && _tower_angle < 230)
689 
                            xx = lerp(piecemaxdistance * -1, 0, (_tower_angle - 130) / 100);
690 
                        if (_tower_angle >= 230 && _tower_angle < 330)
691 
                            xx = lerp(0, piecemaxdistance, (_tower_angle - 230) / 100);
692 
                        if (_tower_angle > 330 || _tower_angle < 130)
693 
                            vis = false;
694 
                    }
695 
                    if (ii == 5)
696 
                    {
697 
                        vis = true;
698 
                        if (_tower_angle >= 165 && _tower_angle < 168)
699 
                            ladder_index = 0;
700 
                        else if (_tower_angle >= 168 && _tower_angle < 181)
701 
                            ladder_index = 1;
702 
                        else if (_tower_angle >= 181 && _tower_angle < 195)
703 
                            ladder_index = 2;
704 
                        else if (_tower_angle >= 195 && _tower_angle < 225)
705 
                            ladder_index = 3;
706 
                        else if (_tower_angle >= 225 && _tower_angle < 305)
707 
                            ladder_index = 4;
708 
                        else if (_tower_angle >= 305 && _tower_angle < 335)
709 
                            ladder_index = 5;
710 
                        else if (_tower_angle >= 335 && _tower_angle < 349)
711 
                            ladder_index = 6;
712 
                        else if (_tower_angle >= 349 || _tower_angle < 2)
713 
                            ladder_index = 7;
714 
                        else if (_tower_angle >= 2 && _tower_angle < 5)
715 
                            ladder_index = 8;
716 
                        else
717 
                            ladder_index = 9;
718 
                        if (_tower_angle >= 165 && _tower_angle < 265)
719 
                            xx = lerp(piecemaxdistance * -1, 0, (_tower_angle - 165) / 100);
720 
                        if (_tower_angle >= 265)
721 
                            xx = lerp(0, piecemaxdistance, (_tower_angle - 265) / 100);
722 
                        if (_tower_angle <= 5)
723 
                            xx = lerp(0, piecemaxdistance, (95 + _tower_angle) / 100);
724 
                        if (_tower_angle > 5 && _tower_angle < 165)
725 
                            vis = false;
726 
                    }
727 
                    if (ii == 6)
728 
                    {
729 
                        vis = true;
730 
                        if (_tower_angle >= 200 && _tower_angle < 203)
731 
                            ladder_index = 0;
732 
                        else if (_tower_angle >= 203 && _tower_angle < 216)
733 
                            ladder_index = 1;
734 
                        else if (_tower_angle >= 216 && _tower_angle < 230)
735 
                            ladder_index = 2;
736 
                        else if (_tower_angle >= 230 && _tower_angle < 260)
737 
                            ladder_index = 3;
738 
                        else if (_tower_angle >= 260 && _tower_angle < 340)
739 
                            ladder_index = 4;
740 
                        else if (_tower_angle >= 340 || _tower_angle < 10)
741 
                            ladder_index = 5;
742 
                        else if (_tower_angle >= 10 && _tower_angle < 24)
743 
                            ladder_index = 6;
744 
                        else if (_tower_angle >= 24 && _tower_angle < 37)
745 
                            ladder_index = 7;
746 
                        else if (_tower_angle >= 37 && _tower_angle < 40)
747 
                            ladder_index = 8;
748 
                        else
749 
                            ladder_index = 9;
750 
                        if (_tower_angle >= 200 && _tower_angle < 300)
751 
                            xx = lerp(piecemaxdistance * -1, 0, (_tower_angle - 200) / 100);
752 
                        if (_tower_angle >= 300)
753 
                            xx = lerp(0, piecemaxdistance, (_tower_angle - 300) / 100);
754 
                        if (_tower_angle <= 40)
755 
                            xx = lerp(0, piecemaxdistance, (60 + _tower_angle) / 100);
756 
                        if (_tower_angle > 40 && _tower_angle < 200)
757 
                            vis = false;
758 
                    }
759 
                    if (ii == 7)
760 
                    {
761 
                        vis = true;
762 
                        if (_tower_angle >= 235 && _tower_angle < 238)
763 
                            ladder_index = 0;
764 
                        else if (_tower_angle >= 238 && _tower_angle < 251)
765 
                            ladder_index = 1;
766 
                        else if (_tower_angle >= 251 && _tower_angle < 265)
767 
                            ladder_index = 2;
768 
                        else if (_tower_angle >= 265 && _tower_angle < 295)
769 
                            ladder_index = 3;
770 
                        else if (_tower_angle >= 295 || _tower_angle < 15)
771 
                            ladder_index = 4;
772 
                        else if (_tower_angle >= 15 && _tower_angle < 45)
773 
                            ladder_index = 5;
774 
                        else if (_tower_angle >= 45 && _tower_angle < 59)
775 
                            ladder_index = 6;
776 
                        else if (_tower_angle >= 59 && _tower_angle < 72)
777 
                            ladder_index = 7;
778 
                        else if (_tower_angle >= 72 && _tower_angle < 75)
779 
                            ladder_index = 8;
780 
                        else
781 
                            ladder_index = 9;
782 
                        if (_tower_angle >= 235 && _tower_angle < 335)
783 
                            xx = lerp(piecemaxdistance * -1, 0, (_tower_angle - 235) / 100);
784 
                        if (_tower_angle >= 335)
785 
                            xx = lerp(0, piecemaxdistance, (_tower_angle - 335) / 100);
786 
                        if (_tower_angle <= 75)
787 
                            xx = lerp(0, piecemaxdistance, (25 + _tower_angle) / 100);
788 
                        if (_tower_angle > 75 && _tower_angle < 235)
789 
                            vis = false;
790 
                    }
791 
                    if (ii == 8)
792 
                    {
793 
                        vis = true;
794 
                        if (_tower_angle >= 270 && _tower_angle < 273)
795 
                            ladder_index = 0;
796 
                        else if (_tower_angle >= 273 && _tower_angle < 286)
797 
                            ladder_index = 1;
798 
                        else if (_tower_angle >= 286 && _tower_angle < 300)
799 
                            ladder_index = 2;
800 
                        else if (_tower_angle >= 300 && _tower_angle < 330)
801 
                            ladder_index = 3;
802 
                        else if (_tower_angle >= 330 || _tower_angle < 50)
803 
                            ladder_index = 4;
804 
                        else if (_tower_angle >= 50 && _tower_angle < 80)
805 
                            ladder_index = 5;
806 
                        else if (_tower_angle >= 80 && _tower_angle < 94)
807 
                            ladder_index = 6;
808 
                        else if (_tower_angle >= 94 && _tower_angle < 107)
809 
                            ladder_index = 7;
810 
                        else if (_tower_angle >= 107 && _tower_angle < 110)
811 
                            ladder_index = 8;
812 
                        else
813 
                            ladder_index = 9;
814 
                        if (_tower_angle >= 270)
815 
                            xx = lerp(piecemaxdistance * -1, 0, (_tower_angle - 270) / 100) - 2;
816 
                        if (_tower_angle <= 10)
817 
                            xx = lerp(0, piecemaxdistance, (_tower_angle - 10) / 100) - 2;
818 
                        if (_tower_angle >= 10 && _tower_angle <= 110)
819 
                            xx = lerp(0, piecemaxdistance, (_tower_angle - 10) / 100) - 2;
820 
                        if (_tower_angle > 110 && _tower_angle < 270)
821 
                            vis = false;
822 
                    }
823 
                    if (ii == 9)
824 
                    {
825 
                        vis = true;
826 
                        if (_tower_angle >= 305 && _tower_angle < 308)
827 
                            ladder_index = 0;
828 
                        else if (_tower_angle >= 308 && _tower_angle < 321)
829 
                            ladder_index = 1;
830 
                        else if (_tower_angle >= 321 && _tower_angle < 335)
831 
                            ladder_index = 2;
832 
                        else if (_tower_angle >= 335 || _tower_angle < 5)
833 
                            ladder_index = 3;
834 
                        else if (_tower_angle >= 5 && _tower_angle < 85)
835 
                            ladder_index = 4;
836 
                        else if (_tower_angle >= 85 && _tower_angle < 115)
837 
                            ladder_index = 5;
838 
                        else if (_tower_angle >= 115 && _tower_angle < 129)
839 
                            ladder_index = 6;
840 
                        else if (_tower_angle >= 129 && _tower_angle < 142)
841 
                            ladder_index = 7;
842 
                        else if (_tower_angle >= 142 && _tower_angle < 145)
843 
                            ladder_index = 8;
844 
                        else
845 
                            ladder_index = 9;
846 
                        if (_tower_angle >= 305)
847 
                            xx = lerp(piecemaxdistance * -1, 0, (_tower_angle - 305) / 100) - 4;
848 
                        if (_tower_angle <= 45)
849 
                            xx = lerp(0, piecemaxdistance, (_tower_angle - 45) / 100) - 4;
850 
                        if (_tower_angle >= 45 && _tower_angle <= 145)
851 
                            xx = lerp(0, piecemaxdistance, (_tower_angle - 45) / 100) - 4;
852 
                        if (_tower_angle > 145 && _tower_angle < 305)
853 
                            vis = false;
854 
                    }
855 
                }
856 
                if (((((40 * i) + yoffset) - (towerpiececount * 40)) > -20 || endclimb == false) && vis == true)
857 
                {
858 
                    if (tower_piece_sprite[i] == 5316)
859 
                    {
860 
                        var bg_index = ladder_index;
861 
                        if (bg_index == 9)
862 
                        {
863 
                        }
864 
                        draw_sprite_ext(spr_tower_rotating_bg, ladder_index, 320 + xx + tower_xoffset[i], ((40 * i) + yoffset) - (towerpiececount * 40), 1.1, 1, 0, c_white, 1);
865 
                    }
866 
                    if (tower_object[i][ii] == 1)
867 
                        draw_sprite(spr_tower_rotating_ladder, ladder_index, 320 + xx + tower_xoffset[i], ((40 * i) + yoffset) - (towerpiececount * 40));
868 
                    if (tower_object[i][ii] == 2)
869 
                        draw_sprite(spr_tower_rotating_steps, ladder_index, 320 + xx + tower_xoffset[i], ((40 * i) + yoffset) - (towerpiececount * 40));
870 
                    if (tower_object[i][ii] == 3)
871 
                        draw_sprite(spr_tower_rotating_rocks, ladder_index, 320 + xx + tower_xoffset[i], ((40 * i) + yoffset) - (towerpiececount * 40));
872 
                    if (tower_object[i][ii] == 4)
873 
                    {
874 
                        draw_sprite(spr_tower_rotating_eye, ladder_index, 320 + xx + tower_xoffset[i], ((40 * i) + yoffset) - (towerpiececount * 40));
875 
                        if (ladder_index != 9 && (eyesmoketimer % 8) == 0)
876 
                            inst = instance_create(((320 + xx + tower_xoffset[i]) - 18) + random(36), (((40 * i) + yoffset) - (towerpiececount * 40)) + 16 + random(12), obj_fountainball);
877 
                    }
878 
                    if (tower_eyedrip[i][ii] > 0)
879 
                    {
880 
                        draw_sprite_ext(spr_tower_rotating_bg, ladder_index, 320 + xx + tower_xoffset[i], ((40 * i) + yoffset) - (towerpiececount * 40), 0.6, tower_eyedrip[i][ii] / 10, 0, c_black, 1);
881 
                        if (tower_eyedrip[i][ii] < 10)
882 
                        {
883 
                            tower_eyedrip[i][ii]++;
884 
                            if (tower_object[i][ii] == 10)
885 
                                tower_eyedrip[i + 1][ii] = 1;
886 
                        }
887 
                    }
888 
                }
889 
            }
890 
        }
891 
    }
892 
}
893 
if (room == room_dw_church_dogclimb)
894 
{
895 
    for (var i = render_ypos_start; i < render_ypos_end; i++)
896 
    {
897 
        for (var ii = 0; ii < 8; ii++)
898 
        {
899 
            var ladder_index = 4;
900 
            var xx = 0;
901 
            if (ii == 6)
902 
            {
903 
                if (tower_angle >= 260 && tower_angle < 266)
904 
                    ladder_index = 0;
905 
                else if (tower_angle >= 267 && tower_angle < 282)
906 
                    ladder_index = 1;
907 
                else if (tower_angle >= 282 && tower_angle < 290)
908 
                    ladder_index = 2;
909 
                else if (tower_angle >= 290 && tower_angle < 335)
910 
                    ladder_index = 3;
911 
                else if (tower_angle >= 335 || tower_angle < 25)
912 
                    ladder_index = 4;
913 
                else if (tower_angle >= 25 && tower_angle < 70)
914 
                    ladder_index = 5;
915 
                else if (tower_angle >= 70 && tower_angle < 78)
916 
                    ladder_index = 6;
917 
                else if (tower_angle >= 78 && tower_angle < 93)
918 
                    ladder_index = 7;
919 
                else if (tower_angle >= 93 && tower_angle < 100)
920 
                    ladder_index = 8;
921 
                else
922 
                    ladder_index = 9;
923 
                if (tower_angle >= 260)
924 
                    xx = lerp(-70, 0, (tower_angle - 260) / 100);
925 
                if (tower_angle < 100)
926 
                    xx = lerp(0, 70, tower_angle / 100);
927 
                if (tower_piece_sprite_dog[i] != 4168)
928 
                {
929 
                    if ((((40 * i) + yoffset) - (towerpiececount * 40)) > -20 || endclimb == false)
930 
                        draw_sprite(spr_tower_rotating_ladder, ladder_index, 560 + xx + tower_xoffset[i], ((40 * i) + yoffset) - (towerpiececount * 40));
931 
                }
932 
            }
933 
        }
934 
    }
935 
}
936 
moved = 0;
937 
if (tower_angle_record[0] != obj_rotating_tower_controller.tower_angle)
938 
    moved = 1;
939 
if (yoffset_record[0] != obj_rotating_tower_controller.yoffset)
940 
    moved = 1;
941 
if (moved == 1)
942 
{
943 
    for (var i = 75; i > 0; i -= 1)
944 
    {
945 
        tower_angle_record[i] = tower_angle_record[i - 1];
946 
        yoffset_record[i] = yoffset_record[i - 1];
947 
        var ex = 0;
948 
        tower_angle_record[0] = tower_angle;
949 
        yoffset_record[0] = yoffset - ex;
950 
    }
951 
}
952 
if (room == room_dw_church_dogclimb)
953 
{
954 
    draw_sprite(spr_dogclimb_top2, 2, 262, -54);
955 
    if (endclimb == false)
956 
        draw_sprite(spr_dogclimb_top2, 2, 502, -54);
957 
}
958 
draw_set_color(c_white);
959 
draw_text(camerax(), 20, "yoffset: " + string(yoffset));
960 
draw_text(camerax(), 40, "tower_angle: " + string(tower_angle));
961 
draw_text(camerax(), 60, "obj_mainchara.y: " + string(obj_mainchara.y));
962 
draw_text(camerax(), 80, "cameray: " + string(cameray()));