Mercurial > hg > Members > koba > t_dandy
annotate Character_state.c @ 29:d2e627af7f61
fix.
author | koba <koba@cr.ie.u-ryukyu.ac.jp> |
---|---|
date | Tue, 28 Dec 2010 16:22:22 +0900 |
parents | 00c3272a801f |
children | 6626e451a09d |
rev | line source |
---|---|
0 | 1 #include <stdio.h> |
2 #include <stdlib.h> | |
3 #include <SDL.h> | |
4 #include "SDL_opengl.h" | |
5 #include "object.h" | |
6 #include "Character.h" | |
7 #include "Character_state.h" | |
8 #include "count2.h" | |
9 #include "schedule.h" | |
10 #include "bom.h" | |
11 #include "sankaku.h" | |
12 #include "sgoex.h" | |
13 #include "collision.h" | |
14 #include "debug.h" | |
15 #include "tama.h" | |
16 | |
17 CHARACTER *kyeenemyno; | |
18 CHARACTER *tekino0; | |
19 CHARACTER *enemy_part1; | |
20 CHARACTER *enemy_part2; | |
21 CHARACTER *enemy_part3; | |
22 CHARACTER *enemy_part4; | |
23 CHARACTER *enemy_part5; | |
24 | |
25 //int tekino0; | |
26 int rinkx; | |
27 int rinky; | |
28 int rinkf1 = 0, rinkf2 = 0; | |
29 CHARACTER *asteroiddt[200]; | |
30 int asteroidi = 0; | |
31 int enemyfaste = 0; | |
32 int fastebos = 0; | |
33 | |
34 CHARACTER * noaction(CHARACTER *p) | |
35 { | |
36 p->state = noaction; | |
37 return p; | |
38 } | |
39 | |
19 | 40 CHARACTER * |
41 delete_chara(CHARACTER *p) | |
42 { | |
43 | |
44 CHARACTER *parent = p; | |
45 p->f = FALSE; | |
46 p->state = noaction; | |
47 p->collision = noaction; | |
48 return parent; | |
49 } | |
50 | |
0 | 51 CHARACTER * chara_state0(CHARACTER *p) |
52 { | |
53 p->x += p->vx; | |
54 p->y += p->vy; | |
55 p->state = chara_state0; | |
56 //PutSprite(count, p->x, p->y, p->charano); | |
57 return p; | |
58 } | |
59 | |
60 CHARACTER * chara_state1(CHARACTER *p) | |
61 { | |
62 p->x -= p->vx; | |
63 p->y -= p->vy; | |
64 p->state = chara_state1; | |
65 //PutSprite(count, p->x, p->y, p->charano); | |
66 return p; | |
67 } | |
68 | |
69 CHARACTER * chara_state2(CHARACTER *p) | |
70 { | |
71 p->vy -= 0.25; | |
72 p->y += p->vy; | |
73 p->state = chara_state2; | |
74 //PutSprite(count, p->x, p->y, p->charano); | |
75 return p; | |
76 } | |
77 | |
78 CHARACTER * chara_state3(CHARACTER *p) | |
79 { | |
80 p->x += p->vx; | |
81 p->y += p->vy; | |
82 if((p->dt1 == 60) || | |
83 (p->dt1 == 90) || | |
84 (p->dt1 == 30)) | |
85 { | |
86 Puttama(0, p->x, p->y); | |
87 } | |
88 p->dt1++; | |
89 p->state = chara_state3; | |
90 //PutSprite(count, p->x, p->y, p->charano); | |
91 return p; | |
92 } | |
93 | |
94 CHARACTER * chara_state4(CHARACTER *p) | |
95 { | |
96 p->y += p->vy; | |
97 p->x += p->vx; | |
98 if(p->y < jiki.y && p->y + 16 > jiki.y) | |
99 { | |
100 p->vy = -2; | |
101 p->vx = ((jiki.x > p->x) ? 4 : -4); | |
102 p->state = chara_state7; | |
103 } | |
104 else p->state = chara_state4; | |
105 //PutSprite(count, p->x, p->y, p->charano); | |
106 return p; | |
107 } | |
108 | |
109 CHARACTER * chara_state5(CHARACTER *p) | |
110 { | |
111 p->y += p->vy; | |
112 p->x += p->vx; | |
113 if(p->y + 96 < jiki.y | |
114 && p->y + 128 > jiki.y) | |
115 { | |
116 p->vy = -2; | |
117 p->vx = ((jiki.x > p->x) ? 4 : -4); | |
118 p->state = chara_state0; | |
119 } | |
120 else p->state = chara_state5; | |
121 //PutSprite(count, p->x, p->y, p->charano); | |
122 return p; | |
123 } | |
124 | |
125 CHARACTER * chara_state6(CHARACTER *p) | |
126 { | |
127 p->y += p->vy; | |
128 p->x += p->vx; | |
129 if(p->y + 96 < jiki.y | |
130 && p->y + 128 > jiki.y) | |
131 { | |
132 p->vy = 2; | |
133 p->vx = ((jiki.x > p->x) ? 4 : -4); | |
134 p->state = chara_state0; | |
135 } | |
136 else p->state = chara_state6; | |
137 //PutSprite(count, p->x, p->y, p->charano); | |
138 return p; | |
139 } | |
140 | |
141 CHARACTER * chara_state7(CHARACTER *p) | |
142 { | |
143 p->x += p->vx; | |
144 p->y += p->vy; | |
145 if((p->dt1 == 60) || (p->dt1 == 90) | |
146 || (p->dt1 == 30)) | |
147 { | |
148 Puttama(1, p->x, p->y); | |
149 } | |
150 p->dt1++; | |
151 p->state = chara_state7; | |
152 //PutSprite(count, p->x, p->y, p->charano); | |
153 return p; | |
154 } | |
155 | |
156 // state1 boss patern | |
157 CHARACTER * chara_state8(CHARACTER *p) | |
158 { | |
159 if(p->y < 520) | |
160 { | |
161 tekino0 = p; | |
162 kyeenemyno = p; | |
163 p->y += p->vy; | |
164 count++; | |
165 DefSpriteEx(p->charano, 16*4, 32*4); | |
166 PutSpriteEx(p->charano, (p->x * 4), (p->y * 4), 0.2, 0.2, 1); | |
167 p->dt1 = 512; | |
168 p->s = 0.125; | |
169 p->state = chara_state8; | |
170 return p; | |
171 } | |
172 p->state = chara_state9; | |
173 return p; | |
174 } | |
175 | |
176 CHARACTER * chara_state9(CHARACTER *p) | |
177 { | |
178 if(p->s <= 2) | |
179 { | |
180 p->s += 0.05; | |
181 p->y -= 12; | |
182 count++; | |
183 DefSpriteEx(54, 16*4, 32*4); | |
184 PutSpriteEx(54, (p->x * 4), (p->y * 4), p->s, p->s, 1); | |
185 p->state = chara_state9; | |
186 return p; | |
187 } | |
188 count++; | |
189 DefSpriteEx(54, 16, 32); | |
190 PutSpriteEx(54, p->x, p->y, p->s, p->s, 1); | |
191 rinkx = p->x; | |
192 rinky = p->y; | |
193 Putenemy(5, rinkx - 16, rinky - 16, 1, 0, chara_state10); | |
194 Putenemy(5, rinkx - 16, rinky - 16, -1, 0, chara_state10); | |
195 p->state = chara_state11; | |
196 p->dt1 = 8192; | |
197 return p; | |
198 } | |
199 | |
200 | |
201 CHARACTER * chara_state10(CHARACTER *p) | |
202 { | |
203 if(p->dt1 < 48) | |
204 { | |
205 p->x += p->vx; | |
206 p->y += p->vy; | |
207 p->dt1++; | |
208 p->state = chara_state10; | |
209 //PutSprite(count, p->x, p->y, | |
210 return p; | |
211 } | |
212 rinkf1 = 1; | |
213 p->dt1 = rinkx; | |
214 p->dt2 = rinky; | |
215 p->state = chara_state13; | |
216 return p; | |
217 } | |
218 | |
219 | |
220 CHARACTER * chara_state11(CHARACTER *p) | |
221 { | |
222 if(rinkf1 == 0) | |
223 { | |
224 count++; | |
225 DefSpriteEx(54, 16, 32); | |
226 PutSpriteEx(54, p->x, p->y, p->s, p->s, 1); | |
227 p->state = chara_state11; | |
228 return p; | |
229 } | |
230 p->dt1 = 0; | |
231 p->dt2 = 0; | |
232 p->state = chara_state12; | |
233 return p; | |
234 } | |
235 | |
236 CHARACTER * chara_state12(CHARACTER *p) | |
237 { | |
238 if(fastebos > 60*60) | |
239 { | |
240 if(p->y > 240+32) | |
241 { | |
242 p->state = delete_chara; | |
243 } | |
244 p->y += 3; | |
245 rinky += 3; | |
246 count++; | |
247 DefSpriteEx(54, 16, 32); | |
248 PutSpriteEx(54, p->x, p->y, 2, 2, 1); | |
249 p->state = chara_state12; | |
250 return p; | |
251 } | |
252 if(p->dt1 <= 60) | |
253 { | |
254 if(jiki.x + 15 - rinkx < -5) | |
255 { | |
256 p->vx = -0.8; | |
257 } | |
258 else if(jiki.x + 15 - rinkx > 5) | |
259 { | |
260 p->vx = +0.8; | |
261 } | |
262 else p->vx = 0; | |
263 rinkx = p->x; | |
264 rinky = p->y; | |
265 } | |
266 if((p->dt1 > 60) && (p->dt1 <= 70)) | |
267 { | |
268 if(p->dt1 % 2 == 1) | |
269 { | |
270 Puttama(0, rinkx - 16, rinky); | |
271 Puttama(0, rinkx, rinky); | |
272 Puttama(0, rinkx + 16, rinky); | |
273 } | |
274 } | |
275 if((p->dt1 > 180) && (p->dt1 <= 240)) | |
276 { | |
277 if(p->dt1 % 2 == 1) | |
278 { | |
279 rinkf2 = 1; | |
280 Puttama(2, rinkx - 16, p->y - 32); | |
281 Puttama(3, rinkx + 32 - 16, p->y - 32); | |
282 } | |
283 else | |
284 { | |
285 rinkf2 = 2; | |
286 } | |
287 } | |
288 if(p->dt1 > 240) | |
289 { | |
290 rinkf2 = 2; | |
291 } | |
292 if((p->dt1 > 240) && (p->dt1 <= 400)) | |
293 { | |
294 count++; | |
295 PutSprite(count, rinkx - 16, rinky + 32, | |
296 58 + p->dt1 % 4); | |
297 } | |
298 if((p->dt1 > 300) && (p->dt1 <= 400)) | |
299 { | |
300 rinkf2 = 3; | |
301 if(jiki.x + 15 - rinkx < -5) | |
302 { | |
303 p->vx = -1; | |
304 } | |
305 else if(jiki.x + 15 - rinkx > 5) | |
306 { | |
307 p->vx = +1; | |
308 } | |
309 else p->vx = 0; | |
310 p->x += p->vx; | |
311 rinkx = p->x; | |
312 rinky = p->y; | |
313 Puttama(4, rinkx - 8, rinky + 16); | |
314 } | |
315 if((p->dt1 > 400) && (p->dt1 <= 500)) | |
316 { | |
317 rinkf2 = 4; | |
318 if(jiki.x + 15 - rinkx > 5) | |
319 { | |
320 p->vx = -1; | |
321 } | |
322 else if(jiki.x + 15 - rinkx > 5) | |
323 { | |
324 p->vx = +1; | |
325 } | |
326 else p->vx = 0; | |
327 p->x += p->vx; | |
328 rinkx = p->x; | |
329 rinky = p->y; | |
330 } | |
331 if(p->dt1 > 500) | |
332 { | |
333 rinkf2 = 5; | |
334 if(jiki.x + 15 - rinkx < -5) | |
335 { | |
336 p->vx = -1; | |
337 } | |
338 else if(jiki.x + 15 - rinkx > 5) | |
339 { | |
340 p->vx = +1; | |
341 } | |
342 else p->vx = 0; | |
343 p->x += p->vx; | |
344 rinkx = p->x; | |
345 rinky = p->y; | |
346 } | |
347 if(p->dt1 > 600) | |
348 { | |
349 rinkf2 = 0; | |
350 p->dt1 = 0; | |
351 } | |
352 fastebos++; | |
353 p->dt1++; | |
354 count++; | |
355 DefSpriteEx(54, 16, 32); | |
356 PutSpriteEx(54, p->x, p->y, 2, 2, 1); | |
357 return p; | |
358 } | |
359 | |
360 | |
361 CHARACTER * chara_state13(CHARACTER *p) | |
362 { | |
363 if(tekino0->f == FALSE){ | |
364 Bom(p->x, p->y); | |
365 p->f = FALSE; | |
366 p->state = delete_chara; | |
367 p->collision = noaction; | |
368 return p; | |
369 } | |
370 | |
371 p->x += rinkx - p->dt1; | |
372 p->y += rinky - p->dt2; | |
373 p->dt1 = rinkx; | |
374 p->dt2 = rinky; | |
375 if(rinkf2 == 1) | |
376 { | |
377 if(p->x > rinkx) | |
378 { | |
379 Puttama(2, p->x + 32, p->y); | |
380 } | |
381 if(p->x < rinkx) | |
382 { | |
383 Puttama(3, p->x, p->y); | |
384 } | |
385 } | |
386 if(rinkf2 == 4) | |
387 { | |
388 count++; | |
389 PutSprite(count, p->x, p->y + 56, 58+filpcount % 4); | |
390 } | |
391 if(rinkf2 == 5) | |
392 { | |
393 if(p->x > rinkx) | |
394 { | |
395 Puttama(5, p->x + 8, p->y + 24); | |
396 } | |
397 if(p->x < rinkx) | |
398 { | |
399 Puttama(5, p->x + 8, p->y + 24); | |
400 } | |
401 } | |
402 return p; | |
403 } | |
404 | |
405 | |
406 CHARACTER * chara_state20(CHARACTER *p) | |
407 { | |
408 p->x += p->vx; | |
409 p->y += p->vy; | |
410 p->vy -= 0.5; | |
411 p->vy += 0.4; | |
412 return p; | |
413 } | |
414 | |
415 CHARACTER * chara_state21(CHARACTER *p) | |
416 { | |
417 p->x += p->vx; | |
418 p->y += p->vy; | |
419 p->vx += 0.5; | |
420 p->vy += 0.4; | |
421 return p; | |
422 } | |
423 | |
424 //ここまでgetate boss | |
425 | |
426 | |
427 CHARACTER * chara_state22(CHARACTER *p) | |
428 { | |
6
9a92435eaee6
divide SG Dandy and Task Dandy.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
429 int sf; |
9a92435eaee6
divide SG Dandy and Task Dandy.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
430 |
0 | 431 sf = rand() % 4; |
432 if((sf == 0) || (sf == 1)) | |
433 { | |
434 p->x = -35; | |
435 p->y = rand() % (120 - 35); | |
436 p->vx = (rand() % 4 + 1); | |
437 p->vy = rand() % 3 + 1; | |
438 p->state = chara_state23; | |
439 } | |
440 if((sf == 2)) | |
441 { | |
442 p->x = rand() % 290; | |
443 p->y = -30; | |
444 p->vx = rand() % 3 - 1; | |
445 p->vy = (rand() % 4 + 1); | |
446 p->state = chara_state23; | |
447 } | |
448 if(sf == 3) | |
449 { | |
450 p->x = 320; | |
451 p->y = rand() % (120 - 35); | |
452 p->vx = (rand() % 4 + 1) * -1; | |
453 p->vy = rand() % 3 -1; | |
454 p->state = chara_state23; | |
455 } | |
456 return p; | |
457 } | |
458 | |
459 CHARACTER * chara_state23(CHARACTER *p) | |
460 { | |
461 p=asteroid(p); | |
462 return p; | |
463 } | |
464 | |
465 CHARACTER * chara_state24(CHARACTER *p) | |
466 { | |
467 kyeenemyno = p; | |
468 tekino0 = 0; | |
469 enemy_part1 = p->next; | |
470 enemy_part2 = enemy_part1->next; | |
471 enemy_part3 = enemy_part2->next; | |
472 enemy_part4 = enemy_part3->next; | |
473 enemy_part5 = enemy_part4->next; | |
474 rinkx = 0; | |
475 rinky = 0; | |
476 rinkf1 = 0; | |
477 rinkf2 = 0; | |
478 p->state = chara_state25; | |
479 return p; | |
480 } | |
481 | |
482 CHARACTER * chara_state25(CHARACTER *p) | |
483 { | |
6
9a92435eaee6
divide SG Dandy and Task Dandy.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
484 int amari; |
9a92435eaee6
divide SG Dandy and Task Dandy.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
485 |
0 | 486 if(p->dt1 <= 360) |
487 { | |
488 p->x = Mycos(p->dt1) * 30 / SANKAKU + 82 + 32; | |
489 p->y = Mysin(p->dt1) * 30 / SANKAKU + 30; | |
490 } | |
491 if(p->dt1 > 360) | |
492 { | |
493 p->x = Mycos(p->dt1) * 30 * -1 /SANKAKU + 142 + 32; | |
494 p->y = Mysin(p->dt1) * 30 / SANKAKU + 30; | |
495 } | |
496 count++; | |
497 PutSprite(count, p->x - 42, p->y, 64); | |
498 amari = rand() % 160; | |
499 if((amari == 1) && (enemy_part5->f == TRUE)) | |
500 { | |
501 p->state = chara_state26; | |
502 rinkf1 = 1; | |
503 } | |
504 if((amari == 2) && (enemy_part1->f == TRUE)) | |
505 { | |
506 p->state = chara_state27; | |
507 rinkf1 = 5; | |
508 rinkx = 0; | |
509 return p; | |
510 } | |
511 if((enemy_part5->f == TRUE) && (enemy_part1->f != TRUE)) | |
512 { | |
513 p->state = chara_state28; | |
514 } | |
515 p->dt1 += 3; | |
516 if(p->dt1 == 720) | |
517 { | |
518 p->dt1 = 0; | |
519 } | |
520 return p; | |
521 } | |
522 | |
523 CHARACTER * chara_state26(CHARACTER *p) | |
524 { | |
525 if((p->dt2 > 50) && (p->dt2 < 100)) | |
526 { | |
527 rinkf1 = 2; | |
528 } | |
529 if(p->dt2 > 100) | |
530 { | |
531 rinkf1 = 3; | |
532 } | |
533 if(p->dt2 == 400) | |
534 { | |
535 rinkf1 = 4; | |
536 } | |
537 count++; | |
538 PutSprite(count, p->x - 42, p->y, 64); | |
539 if(p->dt2 == 401) | |
540 { | |
541 p->dt2 = 0; | |
542 rinkf1 = 0; | |
543 p->state = chara_state25; | |
544 return p; | |
545 } | |
546 p->dt2++; | |
547 return p; | |
548 } | |
549 | |
550 CHARACTER * chara_state27(CHARACTER *p) //rocket punch | |
551 { | |
552 if((p->dt2 > 50) && (p->dt2 < 60) && (p->x > -24) && (p->y > -24)) | |
553 { | |
554 rinkf1 = 6; | |
555 rinkx -= 4; | |
556 p->x -= 4; | |
557 p->y -= 4; | |
558 } | |
559 if(p->dt2 == 80) | |
560 { | |
561 rinkf1 = 7; | |
562 } | |
563 if(p->dt2 == 81) | |
564 { | |
565 rinkf1 = 8; | |
566 } | |
567 if(p->dt2 == 124) | |
568 { | |
569 rinkf1 = 9; | |
570 } | |
571 if(p->dt2 == 400) | |
572 { | |
573 rinkf1 = 10; | |
574 } | |
575 if(p->dt2 == 444) | |
576 { | |
577 rinkf1 = 11; | |
578 } | |
579 if(p->dt2 == 500) | |
580 { | |
581 rinkf1 = 12; | |
582 } | |
583 if((p->dt2 > 80) && (p->dt2 < 200)) | |
584 { | |
585 if((rinkx != 0) && (p->dt2 % 2 == 1)) | |
586 { | |
587 rinkx++; | |
588 p->x++; | |
589 p->y++; | |
590 } | |
591 } | |
592 count++; | |
593 PutSprite(count, p->x - 32, p->y, 6); | |
594 if(rinkf1 == 12) | |
595 { | |
596 p->dt2 = 0; | |
597 rinkf1 = 0; | |
598 rinkx = 0; | |
599 p->state = chara_state25; | |
600 return p; | |
601 } | |
602 p->dt2++; | |
603 return p; | |
604 } | |
605 CHARACTER * chara_state28(CHARACTER *p) | |
606 { | |
607 if (p->dt1 <= 360) | |
608 { | |
609 p->x = Mycos(p->dt1) * 30 / SANKAKU + 82 + 32; | |
610 p->y = Mysin(p->dt1) * 30 / SANKAKU + 30; | |
611 } | |
612 if (p->dt1 > 360) | |
613 { | |
614 p->x = Mycos(p->dt1) * 30 * -1 / SANKAKU + 142 + 32; | |
615 p->y = Mysin(p->dt1) * 30 / SANKAKU + 30; | |
616 } | |
617 count++; | |
618 PutSprite(count, p->x - 42, p->y, 64); | |
619 if (p->dt1 % 30 == 3) | |
620 { | |
621 Putenemy(24, p->x + 14, | |
622 p->y + 14, | |
623 (rand() % 5 + 0.5) * (rand() % 2 == | |
624 1 ? -1 : 1), | |
625 (rand() % 5 + 0.5) * (rand() % 2 == | |
626 1 ? -1 : 1), chara_state29); | |
627 } | |
628 p->dt1 += 3; | |
629 return p; | |
630 } | |
631 | |
632 | |
633 CHARACTER * chara_state29(CHARACTER *p) | |
634 { | |
635 p->x += p->vx; | |
636 p->y += p->vy; | |
637 if(p->dt1 % 18 == 1) | |
638 { | |
639 Puttama(0, p->x, p->y); | |
640 } | |
641 p->dt1++; | |
642 return p; | |
643 } | |
644 | |
645 | |
646 CHARACTER * chara_state30(CHARACTER *p) | |
647 { | |
648 p->x = p->x - 32; | |
649 p->y = p->y; | |
650 return p; | |
651 } | |
652 | |
653 CHARACTER * chara_state31(CHARACTER *p) //right hand | |
654 { | |
655 | |
656 if((enemy_part3->f == FALSE) || (kyeenemyno->f == FALSE)) | |
657 { | |
658 Bom(p->x, p->y); | |
659 p->f = FALSE; | |
660 p->state = delete_chara; | |
661 p->collision = noaction; | |
662 return p; | |
663 } | |
664 | |
665 if(rinkf1 == 0) | |
666 { | |
667 p->x = kyeenemyno->x + 40; | |
668 p->y = kyeenemyno->y + 28; | |
669 p->dt2 = 0; | |
670 } | |
671 if(rinkf1 == 5) | |
672 { | |
673 p->x = kyeenemyno->x + 52; | |
674 p->y = kyeenemyno->y; | |
675 count++; | |
676 PutSprite(count, p->x - 4, p->y - 20, 80 + p->dt2 % 4); | |
677 p->dt2++; | |
678 } | |
679 if(rinkf1 == 6) | |
680 { | |
681 if(p->y < 240 - 40) | |
682 { | |
683 p->y += 6; | |
684 } | |
685 else | |
686 { | |
687 return p; | |
688 } | |
689 count++; | |
690 PutSprite(count, p->x - 4, p->y - 20, 90 + p->dt2 % 4); | |
691 p->dt2++; | |
692 } | |
693 if(rinkf1 == 7) | |
694 { | |
695 Putenemy(22, p->x + 14, p->y + 14, 0, 0, chara_state40); | |
696 return p; | |
697 } | |
698 if(rinkf1 == 11) | |
699 { | |
700 if(p->y + 20 != p->y) | |
701 { | |
702 p->y--; | |
703 } | |
704 else | |
705 { | |
706 return p; | |
707 } | |
708 count++; | |
709 PutSprite(count, p->x + 8, p->y + 44, 58 + p->dt2 % 4); | |
710 p->dt2++; | |
711 } | |
712 return p; | |
713 } | |
714 | |
715 | |
716 CHARACTER * chara_state32(CHARACTER *p) //left hand | |
717 { | |
718 if ((enemy_part4->f == FALSE) | |
719 || (kyeenemyno->f == FALSE)) | |
720 { | |
721 Bom(p->x, p->y); | |
722 p->f = FALSE; | |
723 p->state = delete_chara; | |
724 p->collision = noaction; | |
725 return p; | |
726 } | |
727 p->x = kyeenemyno->x - 40; | |
728 p->y = kyeenemyno->y + 28; | |
729 if (rinkf1 == 5) | |
730 { | |
731 p->x = kyeenemyno->x - 24 + 4; | |
732 p->y = kyeenemyno->y + 28; | |
733 p->charano = enemystate[20].charano; | |
734 } | |
735 if (rinkf1 == 11) | |
736 { | |
737 p->charano = enemystate[14].charano; | |
738 } | |
739 if (rinkf1 == 7) | |
740 { | |
741 Putenemy(23, p->x + 14, | |
742 p->y + 14, 0, 0, chara_state41); | |
743 // rinkf1=8; | |
744 return p; | |
745 } | |
746 return p; | |
747 } | |
748 | |
749 | |
750 CHARACTER * chara_state33(CHARACTER *p) // right shoulder | |
751 { | |
752 if (kyeenemyno->f == FALSE) | |
753 { | |
754 Bom(p->x, p->y); | |
755 p->f = FALSE; | |
756 p->state = delete_chara; | |
757 p->collision = noaction; | |
758 return p; | |
759 } | |
760 p->x = kyeenemyno->x + 32; | |
761 p->y = kyeenemyno->y; | |
762 if (rinkf1 == 5) | |
763 { | |
764 p->x = kyeenemyno->x + 32 - 4; | |
765 p->y = kyeenemyno->y; | |
766 p->charano = enemystate[19].charano; | |
767 } | |
768 if (rinkf1 == 6) | |
769 { | |
770 p->charano = enemystate[11].charano; | |
771 } | |
772 return p; | |
773 } | |
774 | |
775 | |
776 CHARACTER * chara_state34(CHARACTER *p) //left shoulder | |
777 { | |
778 if (kyeenemyno->f == FALSE) | |
779 { | |
780 Bom(p->x, p->y); | |
781 p->f = FALSE; | |
782 p->state = delete_chara; | |
783 p->collision = noaction; | |
784 return p; | |
785 } | |
786 p->x = kyeenemyno->x - 32; | |
787 p->y = kyeenemyno->y; | |
788 if (rinkf1 == 5) | |
789 { | |
790 p->charano = enemystate[21].charano; | |
791 } | |
792 if (rinkf1 == 6) | |
793 { | |
794 p->charano = enemystate[12].charano; | |
795 } | |
796 return p; | |
797 } | |
798 | |
799 CHARACTER * chara_state35(CHARACTER *p) // bust | |
800 { | |
801 if (kyeenemyno->f == FALSE) | |
802 { | |
803 Bom(p->x, p->y); | |
804 p->f = FALSE; | |
805 p->state = delete_chara; | |
806 p->collision = noaction; | |
807 return p; | |
808 } | |
809 p->x = kyeenemyno->x; | |
810 p->y = kyeenemyno->y + 32; | |
811 if (rinkf1 == 1) | |
812 { | |
813 p->charano = enemystate[16].charano; | |
814 } | |
815 if (rinkf1 == 2) | |
816 { | |
817 count++; | |
818 PutSprite(count, p->x - 10, | |
819 p->y + 16, | |
820 58 + p->dt2 % 4); | |
821 count++; | |
822 PutSprite(count, p->x + 10, | |
823 p->y + 16, | |
824 58 + p->dt2 % 4); | |
825 p->dt2++; | |
826 } | |
827 if (rinkf1 == 3) | |
828 { | |
829 count++; | |
830 PutSprite(count, p->x - 10, | |
831 p->y + 16, | |
832 58 + p->dt2 % 4); | |
833 count++; | |
834 PutSprite(count, p->x + 10, | |
835 p->y + 16, | |
836 58 + p->dt2 % 4); | |
837 if (p->dt2 % 20 == 1) | |
838 { | |
839 Puttama(7, p->x, p->y + 16); | |
840 Puttama(7, p->x + 20, | |
841 p->y + 16); | |
842 } | |
843 p->dt2++; | |
844 } | |
845 if (rinkf1 == 4) { | |
846 p->charano = enemystate[15].charano; | |
847 p->dt2 = 0; | |
848 } | |
849 return p; | |
850 } | |
851 | |
852 | |
853 CHARACTER * chara_state40(CHARACTER *p) //arm vulkan | |
854 { | |
855 if (enemy_part1->f == FALSE) | |
856 { | |
857 Bom(p->x, p->y); | |
858 p->f = FALSE; | |
859 p->state = delete_chara; | |
860 p->collision = noaction; | |
861 return p; | |
862 } | |
863 if ((rinkf1 == 8) && (p->dt1 % 3 == 1)) | |
864 { | |
865 if ((p->dt2 < 16)) | |
866 { | |
867 p->dt2++; | |
868 DefSprite(76, "boss2_rightarm_b", 16, p->dt2, 480, boss); | |
869 } | |
870 else | |
871 { | |
872 // rinkf1=9; | |
873 return p; | |
874 } | |
875 } | |
876 if (rinkf1 == 9) | |
877 { | |
878 if (p->dt1 % 15 == 1) | |
879 { | |
880 Puttama(8, p->x, p->y); | |
881 } | |
882 } | |
883 if (rinkf1 == 10) | |
884 { | |
885 if (p->dt2 != 0) | |
886 { | |
887 p->dt2--; | |
888 DefSprite(76, "boss2_rightarm_b", 16, p->dt2, 480, boss); | |
889 } | |
890 else | |
891 { | |
892 p->f = FALSE; | |
893 p->state = delete_chara; | |
894 p->collision = noaction; | |
895 // rinkf1=11; | |
896 } | |
897 } | |
898 p->dt1++; | |
899 return p; | |
900 } | |
901 | |
902 | |
903 CHARACTER * chara_state41(CHARACTER *p) //left arm up arm vulkan | |
904 { | |
905 if (enemy_part2->f == FALSE) | |
906 { | |
907 Bom(p->x, p->y); | |
908 p->f = FALSE; | |
909 p->state = delete_chara; | |
910 p->collision = noaction; | |
911 return p; | |
912 } | |
913 p->x = kyeenemyno->x - 20 - 7; | |
914 p->y = kyeenemyno->y + 28 + 15; | |
915 if ((rinkf1 == 8) && (p->dt1 % 3 == 1)) | |
916 { | |
917 if ((p->dt2 < 16)) | |
918 { | |
919 p->dt2++; | |
920 DefSprite(77, "boss2_leftarmbattery", p->dt2, 16, 480, boss); /*左腕アップアーム砲 */ | |
921 } | |
922 else | |
923 { | |
924 rinkf1 = 9; | |
925 return p; | |
926 } | |
927 } | |
928 if (rinkf1 == 9) | |
929 { | |
930 if (p->dt1 % 15 == 1) | |
931 { | |
932 Puttama(9 + rand() % 2, p->x, p->y); | |
933 } | |
934 } | |
935 if (rinkf1 == 10) | |
936 { | |
937 if (p->dt2 != 0) | |
938 { | |
939 p->dt2--; | |
940 DefSprite(77, "boss2_leftarmbattery", p->dt2, 16, 480, boss); | |
941 } | |
942 else | |
943 { | |
944 p->f = FALSE; | |
945 p->state = delete_chara; | |
946 p->collision = noaction; | |
947 return p; | |
948 // rinkf1=11; | |
949 } | |
950 } | |
951 p->dt1++; | |
952 return p; | |
953 } | |
954 | |
955 | |
956 CHARACTER * chara_state400(CHARACTER *p) | |
957 { | |
958 p->vy++; | |
959 p->y += p->vy / 4; | |
960 p->state = chara_state400; | |
961 return p; | |
962 } | |
963 | |
964 | |
965 CHARACTER * chara_state401(CHARACTER *p) | |
966 { | |
967 p->vx++; | |
968 p->x += p->vx / 8; | |
969 if (p->x > (jiki.x - 32)) | |
970 { | |
971 p->vy--; | |
972 } | |
973 p->y += p->vy / 8; | |
974 if (p->dt1 % 50 == 37) | |
975 { | |
976 Puttama(1, p->x + 8, p->y + 24); | |
977 } | |
978 p->dt1++; | |
979 return p; | |
980 } | |
981 | |
982 | |
983 CHARACTER * chara_state402(CHARACTER *p) | |
984 { | |
985 p->vx--; | |
986 p->x += p->vx / 8; | |
987 if (p->x < (jiki.x + 32)) | |
988 { | |
989 p->vy--; | |
990 } | |
991 p->y += p->vy / 8; | |
992 if (p->dt1 % 50 == 37) | |
993 { | |
994 Puttama(1, p->x + 8, p->y + 24); | |
995 } | |
996 p->dt1++; | |
997 return p; | |
998 } | |
999 | |
1000 | |
1001 CHARACTER * chara_state410(CHARACTER *p) | |
1002 { | |
1003 kyeenemyno = p; | |
1004 p->state = chara_state411; | |
1005 return p; | |
1006 } | |
1007 | |
1008 | |
1009 CHARACTER * chara_state411(CHARACTER *p) | |
1010 { | |
1011 if (p->dt2 > 356) | |
1012 { | |
1013 p->vx = -1; | |
1014 } | |
1015 if (p->dt2 < -398) | |
1016 { | |
1017 p->vx = 1; | |
1018 } | |
1019 if ((p->dt1) % 62 == 0) | |
1020 Putenemy(41, | |
1021 p->x, | |
1022 p->y, | |
1023 (int) -Mycos(p->dt1 / 16) * 4 / | |
1024 SANKAKU, | |
1025 (int) -Mysin(p->dt1 / 16) * 4 / | |
1026 SANKAKU, chara_state7); | |
1027 if ((p->dt1) % 13 == 0) | |
1028 Puttama(11, p->x + 32, | |
1029 p->y + 32); | |
1030 | |
1031 p->dt2 += p->vx; | |
1032 p->dt1 += p->dt2 / 4; | |
1033 | |
1034 p->x = jiki.x - 16 + | |
1035 Mycos(p->dt1 / 16) * 128 / SANKAKU; | |
1036 p->y = jiki.y - 16 + | |
1037 Mysin(p->dt1 / 16) * 128 / SANKAKU; | |
1038 if (p->x < 0) | |
1039 { | |
1040 p->x = 0; | |
1041 } | |
1042 if (p->x > 260) | |
1043 { | |
1044 p->x = 260; | |
1045 } | |
1046 if (p->y < 0) | |
1047 { | |
1048 p->y = 0; | |
1049 } | |
1050 if (p->y > 232) | |
1051 { | |
1052 p->y = 232; | |
1053 } | |
1054 return p; | |
1055 } | |
1056 | |
1057 | |
1058 CHARACTER * chara_state500(CHARACTER *p) | |
1059 { | |
1060 p->s = 0; | |
1061 | |
1062 kyeenemyno = p; | |
1063 p->dt2++; | |
1064 p->dt2 %= 512; | |
1065 p->dt1++; | |
1066 count++; | |
1067 DefSpriteEx(100, 16, 16); | |
1068 // PutSprite(count, enemy[tekino].x + 16, | |
1069 // enemy[tekino].y + 16, 100); | |
1070 PutSpriteEx(100, p->x + 16, p->y + 16, 2, 2, p->dt1); | |
1071 | |
1072 if (p->dt1 % (5 + p->dt2 / 8) == 1) { | |
1073 if (rand() % 2 == 1) | |
1074 Putenemy(24, p->x, p->y, | |
1075 (rand() % 5 + 0.5) * (rand() % 2 == | |
1076 1 ? -1 : 1), | |
1077 (rand() % 5 + 0.5) * (rand() % 2 == | |
1078 1 ? -1 : 1), chara_state501); | |
1079 else | |
1080 Putenemy(rand() % 2 + 1, p->x, | |
1081 p->y, | |
1082 (int) Mycos(p->dt1 / 4) * 4 / | |
1083 SANKAKU, | |
1084 (int) -Mysin(p->dt1 / 4) * 4 / | |
1085 SANKAKU, chara_state501); | |
1086 } | |
1087 if (p->dt1 == 50) { | |
1088 /*Putenemy(44,0,0,1,1,411); */ | |
1089 } | |
1090 return p; | |
1091 } | |
1092 | |
1093 | |
1094 CHARACTER * chara_state501(CHARACTER *p) | |
1095 { | |
1096 p->x += p->vx; | |
1097 p->y += p->vy; | |
1098 if(p->dt1 % 32 == 1) | |
1099 { | |
1100 Puttama(11, p->x, p->y); | |
1101 } | |
1102 p->dt1++; | |
1103 return p; | |
1104 } | |
1105 | |
1106 | |
1107 CHARACTER * chara_state600(CHARACTER *p) | |
1108 { | |
1109 kyeenemyno = p; | |
1110 p->dt1 += 30; | |
1111 p->dt2++; | |
1112 p->dt1 %= 360; | |
1113 p->x += Mycos(p->dt1) * 4 / SANKAKU; | |
1114 p->y += Mysin(p->dt1) * 4 / SANKAKU; | |
1115 Puttama(11, p->x + 16, p->y + 16); | |
1116 Puttama(11, p->x + 32, p->y + 48); | |
1117 Puttama(11, p->x + 48, p->y + 16); | |
1118 if (p->dt2 > 240) | |
1119 p->state = chara_state601; | |
1120 if (p->x < 0) | |
1121 p->x = 0; | |
1122 if (p->x > 260) | |
1123 p->x = 260; | |
1124 if (p->y < 0) | |
1125 p->y = 0; | |
1126 if (p->y > 232) | |
1127 p->y = 232; | |
1128 return p; | |
1129 } | |
1130 | |
1131 | |
1132 CHARACTER * chara_state601(CHARACTER *p) | |
1133 { | |
1134 p->dt2++; | |
1135 if (p->x < jiki.x) | |
1136 p->vx++; | |
1137 if (p->x > jiki.x) | |
1138 p->vx--; | |
1139 p->x += p->vx; | |
1140 Putenemy(6, p->x + 16 + rand() % 32, | |
1141 p->y, 0, rand() % 4, chara_state400); | |
1142 if (p->x < 0) | |
1143 p->x = 0; | |
1144 if (p->x > 260) | |
1145 p->x = 260; | |
1146 if (p->y < 0) | |
1147 p->y = 0; | |
1148 if (p->y > 232) | |
1149 p->y = 232; | |
1150 if (p->dt2 > 800) { | |
1151 p->state = chara_state602; | |
1152 } | |
1153 return p; | |
1154 } | |
1155 | |
1156 | |
1157 CHARACTER * chara_state602(CHARACTER *p) | |
1158 { | |
1159 p->dt2++; | |
1160 Putenemy(24, p->x + 14, p->y + 14, | |
1161 (rand() % 5 + 0.5) * (rand() % 2 == 1 ? -1 : 1), | |
1162 (rand() % 5 + 0.5) * (rand() % 2 == 1 ? -1 : 1), | |
1163 chara_state29); | |
1164 if (p->dt2 > 1024) { | |
1165 p->state = chara_state600; | |
1166 p->dt2 = 0; | |
1167 } | |
1168 return p; | |
1169 } | |
1170 | |
1171 | |
1172 CHARACTER * asteroid(CHARACTER *p) | |
1173 { | |
1174 int i; | |
1175 | |
1176 asteroiddt[asteroidi] = p; | |
1177 // if(asteroidi==0) | |
1178 // { | |
1179 p->x += p->vx; | |
1180 p->y += p->vy; | |
1181 // } | |
1182 if (asteroidi > 0) { | |
1183 for (i = 0; i < asteroidi; i++) { | |
1184 if ((asteroiddt[i]->x + 32 > p->x) | |
1185 && (p->x + 32 > asteroiddt[i]->x) | |
1186 && (asteroiddt[i]->y + 32 > p->y) | |
1187 && (asteroiddt[i]->y < p->y + 32)) { | |
1188 p->vx *= -1; | |
1189 p->vy *= -1; | |
1190 } | |
1191 } | |
1192 } | |
1193 asteroidi++; | |
1194 return p; | |
1195 } |