Mercurial > hg > Members > koba > t_dandy

comparison state_task.cc @ 34:7aaaaf5dde40

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
add new task.
author koba <koba@cr.ie.u-ryukyu.ac.jp>
date Fri, 07 Jan 2011 23:19:05 +0900
parents 39e643fc4f90
children c122e3d2302e
comparison
equal deleted inserted replaced
33:39e643fc4f90 34:7aaaaf5dde40
77 77
78 SetTaskState(STATE20, chara_state20); 78 SetTaskState(STATE20, chara_state20);
79 SetTaskState(STATE21, chara_state21); 79 SetTaskState(STATE21, chara_state21);
80 SetTaskState(STATE22, chara_state22); 80 SetTaskState(STATE22, chara_state22);
81 SetTaskState(STATE23, chara_state23); 81 SetTaskState(STATE23, chara_state23);
82 #if 0
83 SetTaskState(STATE24, chara_state24); 82 SetTaskState(STATE24, chara_state24);
84 SetTaskState(STATE25, chara_state25); 83 SetTaskState(STATE25, chara_state25);
85 SetTaskState(STATE26, chara_state26); 84 SetTaskState(STATE26, chara_state26);
86 SetTaskState(STATE27, chara_state27); 85 SetTaskState(STATE27, chara_state27);
87 SetTaskState(STATE28, chara_state28); 86 SetTaskState(STATE28, chara_state28);
88 SetTaskState(STATE29, chara_state29); 87 SetTaskState(STATE29, chara_state29);
89 #endif
90 SetTaskState(STATE30, chara_state30); 88 SetTaskState(STATE30, chara_state30);
91 #if 0
92 SetTaskState(STATE31, chara_state31); 89 SetTaskState(STATE31, chara_state31);
93 SetTaskState(STATE32, chara_state32); 90 SetTaskState(STATE32, chara_state32);
91 #if 0
94 SetTaskState(STATE33, chara_state33); 92 SetTaskState(STATE33, chara_state33);
95 SetTaskState(STATE34, chara_state34); 93 SetTaskState(STATE34, chara_state34);
96 SetTaskState(STATE35, chara_state35); 94 SetTaskState(STATE35, chara_state35);
97 SetTaskState(STATE40, chara_state40); 95 SetTaskState(STATE40, chara_state40);
98 SetTaskState(STATE41, chara_state41); 96 SetTaskState(STATE41, chara_state41);
97 #endif
99 SetTaskState(STATE400, chara_state400); 98 SetTaskState(STATE400, chara_state400);
100 SetTaskState(STATE401, chara_state401); 99 SetTaskState(STATE401, chara_state401);
101 SetTaskState(STATE402, chara_state402); 100 SetTaskState(STATE402, chara_state402);
101 #if 0
102 SetTaskState(STATE410, chara_state410); 102 SetTaskState(STATE410, chara_state410);
103 SetTaskState(STATE411, chara_state411); 103 SetTaskState(STATE411, chara_state411);
104 SetTaskState(STATE500, chara_state500); 104 SetTaskState(STATE500, chara_state500);
105 SetTaskState(STATE501, chara_state501); 105 SetTaskState(STATE501, chara_state501);
106 SetTaskState(STATE600, chara_state600); 106 SetTaskState(STATE600, chara_state600);
112 void 112 void
113 updateState(SchedTask *s, void *chara, void *arg) 113 updateState(SchedTask *s, void *chara, void *arg)
114 { 114 {
115 CHARACTER *p = (CHARACTER*)chara; 115 CHARACTER *p = (CHARACTER*)chara;
116 116
117 int num = GetStateNum(p->task);
118 p->state = state_list[num];
119 }
120
121
122 void
123 freeObject(SchedTask *s, void *chara, void *obj)
124 {
125 free(obj);
126
127 CHARACTER *p = (CHARACTER*)chara;
117 int num = GetStateNum(p->task); 128 int num = GetStateNum(p->task);
118 p->state = state_list[num]; 129 p->state = state_list[num];
119 } 130 }
120 131
121 132
223 return p; 234 return p;
224 } 235 }
225 236
226 237
227 CHARACTER* 238 CHARACTER*
228 BossTask1(CHARACTER *p) 239 JikiContainerTask(CHARACTER *p)
229 { 240 {
230 int task_num = p->task; 241 int task_num = p->task;
231 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; 242 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
232 HTaskPtr state_task = tmanager->create_task(task_num); 243 HTaskPtr state_task = tmanager->create_task(task_num);
233 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); 244 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
234 obj->flag = false; 245 obj->flag = false;
235 obj->length = 0; 246 obj->length = 0;
236 247
237 state_task->set_param(0, (memaddr)count); 248 state_task->set_inData(0, p, sizeof(CHARACTER));
238 249 state_task->set_inData(1, &jiki, sizeof(player));
239 state_task->set_inData(0, p, sizeof(CHARACTER)); 250
240 251 state_task->set_outData(0, p, sizeof(CHARACTER));
241 state_task->set_outData(0, p, sizeof(CHARACTER)); 252 state_task->set_outData(1, obj, 0);
242 state_task->set_outData(1, &count, sizeof(int)); 253
243 state_task->set_outData(2, obj, 0); 254 state_task->set_post(checkContainer, (void*)p, (void*)obj);
244 255 state_task->set_cpu(SPE_ANY);
245 state_task->set_post(checkContainer, (void*)p, (void*)obj); 256 state_task->spawn();
246 state_task->set_cpu(SPE_ANY); 257
247 state_task->spawn(); 258 return p;
248 259 }
249 return p; 260
250 } 261
251 262 CHARACTER*
252 263 AsteroidTask(CHARACTER *p)
253 CHARACTER* 264 {
254 BossTask2(CHARACTER *p) 265 asteroiddt[asteroidi] = p;
266
267 int task_num = ASTEROID_TASK;
268 HTaskPtr state_task = tmanager->create_task(task_num);
269
270 state_task->set_param(0, (memaddr)asteroidi);
271
272 state_task->set_inData(0, p, sizeof(CHARACTER));
273
274 state_task->set_outData(0, p, sizeof(CHARACTER));
275
276 int array_size = sizeof(CHARACTER)*asteroidi;
277 if (array_size > 0) {
278 CHARACTER *asteroid_array = (CHARACTER*)tmanager->allocate(array_size);
279 for (int i = 0; i < asteroidi; i++) {
280 asteroid_array[i] = *asteroiddt[i];
281 }
282 state_task->set_inData(1, asteroid_array, array_size);
283 state_task->set_post(freeObject, (void*)p, (void*)asteroid_array);
284 } else {
285 state_task->set_post(updateState, (void*)p, NULL);
286 }
287 state_task->set_cpu(SPE_ANY);
288 state_task->spawn();
289
290 asteroidi++;
291 return p;
292 }
293
294
295 CHARACTER*
296 Boss1Task1(CHARACTER *p)
255 { 297 {
256 int task_num = p->task; 298 int task_num = p->task;
257 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; 299 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
258 HTaskPtr state_task = tmanager->create_task(task_num); 300 HTaskPtr state_task = tmanager->create_task(task_num);
259 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); 301 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
260 obj->flag = false; 302 obj->flag = false;
261 obj->length = 0; 303 obj->length = 0;
262 304
263 state_task->set_param(0, (memaddr)count); 305 state_task->set_inData(0, p, sizeof(CHARACTER));
264 306 state_task->set_inData(1, &count, sizeof(int));
265 state_task->set_inData(0, p, sizeof(CHARACTER)); 307
308 state_task->set_outData(0, p, sizeof(CHARACTER));
309 state_task->set_outData(1, &count, sizeof(int));
310 state_task->set_outData(2, obj, 0);
311
312 state_task->set_post(checkContainer, (void*)p, (void*)obj);
313 state_task->set_cpu(SPE_ANY);
314 state_task->spawn();
315
316 return p;
317 }
318
319
320 CHARACTER*
321 Boss1Task2(CHARACTER *p)
322 {
323 int task_num = p->task;
324 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
325 HTaskPtr state_task = tmanager->create_task(task_num);
326 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
327 obj->flag = false;
328 obj->length = 0;
329
330 state_task->set_inData(0, p, sizeof(CHARACTER));
331 state_task->set_inData(1, &count, sizeof(int));
266 332
267 state_task->set_outData(0, p, sizeof(CHARACTER)); 333 state_task->set_outData(0, p, sizeof(CHARACTER));
268 state_task->set_outData(1, &count, sizeof(int)); 334 state_task->set_outData(1, &count, sizeof(int));
269 state_task->set_outData(2, &rinkx, sizeof(int)); 335 state_task->set_outData(2, &rinkx, sizeof(int));
270 state_task->set_outData(3, &rinky, sizeof(int)); 336 state_task->set_outData(3, &rinky, sizeof(int));
277 return p; 343 return p;
278 } 344 }
279 345
280 346
281 CHARACTER* 347 CHARACTER*
282 BossTask3(CHARACTER *p) 348 Boss1Task3(CHARACTER *p)
283 { 349 {
284 int task_num = p->task; 350 int task_num = p->task;
285 HTaskPtr state_task = tmanager->create_task(task_num); 351 HTaskPtr state_task = tmanager->create_task(task_num);
286 352
287 state_task->set_param(0, (memaddr)rinkx); 353 state_task->set_param(0, (memaddr)rinkx);
299 return p; 365 return p;
300 } 366 }
301 367
302 368
303 CHARACTER* 369 CHARACTER*
304 BossTask4(CHARACTER *p) 370 Boss1Task4(CHARACTER *p)
305 { 371 {
306 int task_num = p->task; 372 int task_num = p->task;
307 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; 373 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
308 HTaskPtr state_task = tmanager->create_task(task_num); 374 HTaskPtr state_task = tmanager->create_task(task_num);
309 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); 375 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
326 return p; 392 return p;
327 } 393 }
328 394
329 395
330 CHARACTER* 396 CHARACTER*
331 BossTask5(CHARACTER *p) 397 Boss1Task5(CHARACTER *p)
332 { 398 {
333 int task_num = p->task; 399 int task_num = p->task;
334 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; 400 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
335 HTaskPtr state_task = tmanager->create_task(task_num); 401 HTaskPtr state_task = tmanager->create_task(task_num);
336 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); 402 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
360 return p; 426 return p;
361 } 427 }
362 428
363 429
364 CHARACTER* 430 CHARACTER*
365 BossTask6(CHARACTER *p) 431 Boss1Task6(CHARACTER *p)
366 { 432 {
367 int task_num = p->task; 433 int task_num = p->task;
368 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; 434 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
369 HTaskPtr state_task = tmanager->create_task(task_num); 435 HTaskPtr state_task = tmanager->create_task(task_num);
370 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); 436 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
371 obj->flag = false; 437 obj->flag = false;
372 obj->length = 0; 438 obj->length = 0;
373 439
374 state_task->set_param(0, (memaddr)rinkx); 440 state_task->set_param(0, (memaddr)rinkx);
375 state_task->set_param(1, (memaddr)rinky); 441 state_task->set_param(1, (memaddr)rinky);
376 state_task->set_param(2, (memaddr)rinkf2); 442 state_task->set_param(2, (memaddr)filpcount);
377 state_task->set_param(3, (memaddr)count); 443 state_task->set_param(3, (memaddr)tekino0->f);
378 state_task->set_param(4, (memaddr)filpcount); 444 state_task->set_param(4, (memaddr)count);
379 state_task->set_param(5, (memaddr)tekino0->f); 445
380 state_task->set_param(6, (memaddr)bomend); 446 state_task->set_inData(0, p, sizeof(CHARACTER));
381 447 state_task->set_inData(1, bchar, sizeof(bomchar)*100);
382 state_task->set_inData(0, p, sizeof(CHARACTER)); 448 state_task->set_inData(2, &bomend, sizeof(int));
383 state_task->set_inData(1, bchar, sizeof(bomchar)*(bomend+1)); 449 state_task->set_inData(3, &rinkf2, sizeof(int));
384 450
385 state_task->set_outData(0, p, sizeof(CHARACTER)); 451 state_task->set_outData(0, p, sizeof(CHARACTER));
386 state_task->set_outData(1, &count, sizeof(int)); 452 state_task->set_outData(1, &count, sizeof(int));
387 state_task->set_outData(2, &bomend, sizeof(int)); 453 state_task->set_outData(2, &bomend, sizeof(int));
388 state_task->set_outData(3, obj, 0); 454 state_task->set_outData(3, bchar, sizeof(bomchar)*100);
455 state_task->set_outData(4, obj, 0);
456
457 state_task->set_post(checkContainer, (void*)p, (void*)obj);
458 state_task->set_cpu(SPE_ANY);
459 state_task->spawn();
460
461 return p;
462 }
463
464
465 CHARACTER*
466 Boss2Task1(CHARACTER *p)
467 {
468 int task_num = p->task;
469 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
470 HTaskPtr state_task = tmanager->create_task(task_num);
471 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
472 obj->flag = false;
473 obj->length = 0;
474
475 state_task->set_param(0, (memaddr)enemy_part1->f);
476 state_task->set_param(1, (memaddr)enemy_part5->f);
477
478 state_task->set_inData(0, p, sizeof(CHARACTER));
479 state_task->set_inData(1, &count, sizeof(int));
480 state_task->set_inData(2, &rinkx, sizeof(int));
481 state_task->set_inData(3, &rinkf1, sizeof(int));
482
483 state_task->set_outData(0, p, sizeof(CHARACTER));
484 state_task->set_outData(1, &count, sizeof(int));
485 state_task->set_outData(2, &rinkx, sizeof(int));
486 state_task->set_outData(3, &rinkf1, sizeof(int));
487 state_task->set_outData(4, obj, 0);
488
489 state_task->set_post(checkContainer, (void*)p, (void*)obj);
490 state_task->set_cpu(SPE_ANY);
491 state_task->spawn();
492
493 return p;
494 }
495
496
497 CHARACTER*
498 Boss2Task2(CHARACTER *p)
499 {
500 int task_num = p->task;
501 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
502 HTaskPtr state_task = tmanager->create_task(task_num);
503 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
504 obj->flag = false;
505 obj->length = 0;
506
507 state_task->set_param(0, (memaddr)enemy_part3->f);
508 state_task->set_param(1, (memaddr)enemy_part4->f);
509 state_task->set_param(2, (memaddr)enemystate[14].charano);
510 state_task->set_param(3, (memaddr)enemystate[20].charano);
511
512 state_task->set_inData(0, p, sizeof(CHARACTER));
513 state_task->set_inData(1, kyeenemyno, sizeof(CHARACTER));
514 state_task->set_inData(2, &count, sizeof(int));
515 state_task->set_inData(3, &rinkf1, sizeof(int));
516 state_task->set_inData(4, bchar, sizeof(bomchar)*100);
517
518 state_task->set_outData(0, p, sizeof(CHARACTER));
519 state_task->set_outData(1, &count, sizeof(int));
520 state_task->set_outData(2, &rinkx, sizeof(int));
521 state_task->set_outData(3, &rinkf1, sizeof(int));
522 state_task->set_outData(4, obj, 0);
389 523
390 state_task->set_post(checkContainer, (void*)p, (void*)obj); 524 state_task->set_post(checkContainer, (void*)p, (void*)obj);
391 state_task->set_cpu(SPE_ANY); 525 state_task->set_cpu(SPE_ANY);
392 state_task->spawn(); 526 state_task->spawn();
393 527
485 { 619 {
486 tekino0 = p; 620 tekino0 = p;
487 kyeenemyno = p; 621 kyeenemyno = p;
488 622
489 p->task = STATE8; 623 p->task = STATE8;
490 return BossTask1(p); 624 return Boss1Task1(p);
491 } 625 }
492 626
493 627
494 CHARACTER* 628 CHARACTER*
495 chara_state9(CHARACTER *p) 629 chara_state9(CHARACTER *p)
496 { 630 {
497 p->task = STATE9; 631 p->task = STATE9;
498 return BossTask2(p); 632 return Boss1Task2(p);
499 } 633 }
500 634
501 635
502 CHARACTER* 636 CHARACTER*
503 chara_state10(CHARACTER *p) 637 chara_state10(CHARACTER *p)
504 { 638 {
505 p->task =STATE10; 639 p->task =STATE10;
506 return BossTask3(p); 640 return Boss1Task3(p);
507 } 641 }
508 642
509 643
510 CHARACTER* 644 CHARACTER*
511 chara_state11(CHARACTER *p) 645 chara_state11(CHARACTER *p)
512 { 646 {
513 p->task = STATE11; 647 p->task = STATE11;
514 return BossTask4(p); 648 return Boss1Task4(p);
515 } 649 }
516 650
517 651
518 CHARACTER* 652 CHARACTER*
519 chara_state12(CHARACTER *p) 653 chara_state12(CHARACTER *p)
520 { 654 {
521 p->task = STATE12; 655 p->task = STATE12;
522 return BossTask5(p); 656 return Boss1Task5(p);
523 } 657 }
524 658
525 659
526 CHARACTER* 660 CHARACTER*
527 chara_state13(CHARACTER *p) 661 chara_state13(CHARACTER *p)
528 { 662 {
529 p->task = STATE13; 663 p->task = STATE13;
530 return BossTask6(p); 664 return Boss1Task6(p);
531 } 665 }
532 666
533 667
534 CHARACTER* 668 CHARACTER*
535 chara_state20(CHARACTER *p) 669 chara_state20(CHARACTER *p)
546 return SimpleStateTask(p); 680 return SimpleStateTask(p);
547 } 681 }
548 //ここまでgetate boss 682 //ここまでgetate boss
549 683
550 684
551 CHARACTER * chara_state22(CHARACTER *p) 685 CHARACTER*
552 { 686 chara_state22(CHARACTER *p)
687 {
688 p->task = STATE22;
553 return SimpleStateTask(p); 689 return SimpleStateTask(p);
554 } 690 }
555 691
556 692
557 CHARACTER * chara_state23(CHARACTER *p) 693 CHARACTER*
558 { 694 chara_state23(CHARACTER *p)
559 // p=asteroid(p); 695 {
560 return p; 696 p->task = STATE23;
561 } 697 return AsteroidTask(p);
562 698 }
563 699
564 #if 0 700
565 CHARACTER * chara_state24(CHARACTER *p) 701 CHARACTER*
566 { 702 chara_state24(CHARACTER *p)
567 kyeenemyno = p; 703 {
568 tekino0 = 0; 704 kyeenemyno = p;
569 enemy_part1 = p->next; 705 tekino0 = 0;
570 enemy_part2 = enemy_part1->next; 706 enemy_part1 = p->next;
571 enemy_part3 = enemy_part2->next; 707 enemy_part2 = enemy_part1->next;
572 enemy_part4 = enemy_part3->next; 708 enemy_part3 = enemy_part2->next;
573 enemy_part5 = enemy_part4->next; 709 enemy_part4 = enemy_part3->next;
574 rinkx = 0; 710 enemy_part5 = enemy_part4->next;
575 rinky = 0; 711 rinkx = 0;
576 rinkf1 = 0; 712 rinky = 0;
577 rinkf2 = 0; 713 rinkf1 = 0;
578 p->state = chara_state25; 714 rinkf2 = 0;
579 return p; 715 p->task = STATE25;
580 } 716
581 717 int num = GetStateNum(p->task);
582 CHARACTER * chara_state25(CHARACTER *p) 718 p->state = state_list[num];
583 { 719 return p;
584 int amari; 720 }
585 721
586 if(p->dt1 <= 360) 722 CHARACTER*
587 { 723 chara_state25(CHARACTER *p)
588 p->x = Mycos(p->dt1) * 30 / SANKAKU + 82 + 32; 724 {
589 p->y = Mysin(p->dt1) * 30 / SANKAKU + 30; 725 p->task = STATE25;
590 } 726 return Boss2Task1(p);
591 if(p->dt1 > 360) 727 }
592 { 728
593 p->x = Mycos(p->dt1) * 30 * -1 /SANKAKU + 142 + 32; 729 CHARACTER*
594 p->y = Mysin(p->dt1) * 30 / SANKAKU + 30; 730 chara_state26(CHARACTER *p)
595 } 731 {
596 count++; 732 p->task = STATE26;
597 PutSprite(count, p->x - 42, p->y, 64); 733 return Boss2Task1(p);
598 amari = rand() % 160; 734 }
599 if((amari == 1) && (enemy_part5->f == TRUE)) 735
600 { 736 CHARACTER*
601 p->state = chara_state26; 737 chara_state27(CHARACTER *p) //rocket punch
602 rinkf1 = 1; 738 {
603 } 739 p->task = STATE27;
604 if((amari == 2) && (enemy_part1->f == TRUE)) 740 return Boss2Task1(p);
605 { 741 }
606 p->state = chara_state27; 742 CHARACTER*
607 rinkf1 = 5; 743 chara_state28(CHARACTER *p)
608 rinkx = 0; 744 {
609 return p; 745 p->task = STATE28;
610 } 746 return Boss2Task1(p);
611 if((enemy_part5->f == TRUE) && (enemy_part1->f != TRUE)) 747 }
612 { 748
613 p->state = chara_state28; 749
614 } 750 CHARACTER*
615 p->dt1 += 3; 751 chara_state29(CHARACTER *p)
616 if(p->dt1 == 720) 752 {
617 { 753 p->task = STATE29;
618 p->dt1 = 0; 754 return sendContainerTask(p);
619 } 755 }
620 return p; 756
621 } 757
622 758 CHARACTER*
623 CHARACTER * chara_state26(CHARACTER *p) 759 chara_state30(CHARACTER *p)
624 {
625 if((p->dt2 > 50) && (p->dt2 < 100))
626 {
627 rinkf1 = 2;
628 }
629 if(p->dt2 > 100)
630 {
631 rinkf1 = 3;
632 }
633 if(p->dt2 == 400)
634 {
635 rinkf1 = 4;
636 }
637 count++;
638 PutSprite(count, p->x - 42, p->y, 64);
639 if(p->dt2 == 401)
640 {
641 p->dt2 = 0;
642 rinkf1 = 0;
643 p->state = chara_state25;
644 return p;
645 }
646 p->dt2++;
647 return p;
648 }
649
650 CHARACTER * chara_state27(CHARACTER *p) //rocket punch
651 {
652 if((p->dt2 > 50) && (p->dt2 < 60) && (p->x > -24) && (p->y > -24))
653 {
654 rinkf1 = 6;
655 rinkx -= 4;
656 p->x -= 4;
657 p->y -= 4;
658 }
659 if(p->dt2 == 80)
660 {
661 rinkf1 = 7;
662 }
663 if(p->dt2 == 81)
664 {
665 rinkf1 = 8;
666 }
667 if(p->dt2 == 124)
668 {
669 rinkf1 = 9;
670 }
671 if(p->dt2 == 400)
672 {
673 rinkf1 = 10;
674 }
675 if(p->dt2 == 444)
676 {
677 rinkf1 = 11;
678 }
679 if(p->dt2 == 500)
680 {
681 rinkf1 = 12;
682 }
683 if((p->dt2 > 80) && (p->dt2 < 200))
684 {
685 if((rinkx != 0) && (p->dt2 % 2 == 1))
686 {
687 rinkx++;
688 p->x++;
689 p->y++;
690 }
691 }
692 count++;
693 PutSprite(count, p->x - 32, p->y, 6);
694 if(rinkf1 == 12)
695 {
696 p->dt2 = 0;
697 rinkf1 = 0;
698 rinkx = 0;
699 p->state = chara_state25;
700 return p;
701 }
702 p->dt2++;
703 return p;
704 }
705 CHARACTER * chara_state28(CHARACTER *p)
706 {
707 if (p->dt1 <= 360)
708 {
709 p->x = Mycos(p->dt1) * 30 / SANKAKU + 82 + 32;
710 p->y = Mysin(p->dt1) * 30 / SANKAKU + 30;
711 }
712 if (p->dt1 > 360)
713 {
714 p->x = Mycos(p->dt1) * 30 * -1 / SANKAKU + 142 + 32;
715 p->y = Mysin(p->dt1) * 30 / SANKAKU + 30;
716 }
717 count++;
718 PutSprite(count, p->x - 42, p->y, 64);
719 if (p->dt1 % 30 == 3)
720 {
721 Putenemy(24, p->x + 14,
722 p->y + 14,
723 (rand() % 5 + 0.5) * (rand() % 2 ==
724 1 ? -1 : 1),
725 (rand() % 5 + 0.5) * (rand() % 2 ==
726 1 ? -1 : 1), chara_state29);
727 }
728 p->dt1 += 3;
729 return p;
730 }
731
732
733 CHARACTER * chara_state29(CHARACTER *p)
734 {
735 p->x += p->vx;
736 p->y += p->vy;
737 if(p->dt1 % 18 == 1)
738 {
739 Puttama(0, p->x, p->y);
740 }
741 p->dt1++;
742 return p;
743 }
744 #endif
745
746 CHARACTER * chara_state30(CHARACTER *p)
747 { 760 {
748 p->task = STATE30; 761 p->task = STATE30;
749 return SimpleStateTask(p); 762 return SimpleStateTask(p);
750 } 763 }
751 764
765
766 CHARACTER*
767 chara_state31(CHARACTER *p) //right hand
768 {
769 p->task = STATE31;
770 return Boss2Task2(p);
771 }
772
773
774 CHARACTER*
775 chara_state32(CHARACTER *p) //left hand
776 {
777 p->task = STATE32;
778 return Boss2Task2(p);
779 }
780
781
752 #if 0 782 #if 0
753 CHARACTER * chara_state31(CHARACTER *p) //right hand
754 {
755
756 if((enemy_part3->f == FALSE) || (kyeenemyno->f == FALSE))
757 {
758 Bom(p->x, p->y);
759 p->f = FALSE;
760 p->state = delete_chara;
761 p->collision = noaction;
762 return p;
763 }
764
765 if(rinkf1 == 0)
766 {
767 p->x = kyeenemyno->x + 40;
768 p->y = kyeenemyno->y + 28;
769 p->dt2 = 0;
770 }
771 if(rinkf1 == 5)
772 {
773 p->x = kyeenemyno->x + 52;
774 p->y = kyeenemyno->y;
775 count++;
776 PutSprite(count, p->x - 4, p->y - 20, 80 + p->dt2 % 4);
777 p->dt2++;
778 }
779 if(rinkf1 == 6)
780 {
781 if(p->y < 240 - 40)
782 {
783 p->y += 6;
784 }
785 else
786 {
787 return p;
788 }
789 count++;
790 PutSprite(count, p->x - 4, p->y - 20, 90 + p->dt2 % 4);
791 p->dt2++;
792 }
793 if(rinkf1 == 7)
794 {
795 Putenemy(22, p->x + 14, p->y + 14, 0, 0, chara_state40);
796 return p;
797 }
798 if(rinkf1 == 11)
799 {
800 if(p->y + 20 != p->y)
801 {
802 p->y--;
803 }
804 else
805 {
806 return p;
807 }
808 count++;
809 PutSprite(count, p->x + 8, p->y + 44, 58 + p->dt2 % 4);
810 p->dt2++;
811 }
812 return p;
813 }
814
815
816 CHARACTER * chara_state32(CHARACTER *p) //left hand
817 {
818 if ((enemy_part4->f == FALSE)
819 || (kyeenemyno->f == FALSE))
820 {
821 Bom(p->x, p->y);
822 p->f = FALSE;
823 p->state = delete_chara;
824 p->collision = noaction;
825 return p;
826 }
827 p->x = kyeenemyno->x - 40;
828 p->y = kyeenemyno->y + 28;
829 if (rinkf1 == 5)
830 {
831 p->x = kyeenemyno->x - 24 + 4;
832 p->y = kyeenemyno->y + 28;
833 p->charano = enemystate[20].charano;
834 }
835 if (rinkf1 == 11)
836 {
837 p->charano = enemystate[14].charano;
838 }
839 if (rinkf1 == 7)
840 {
841 Putenemy(23, p->x + 14,
842 p->y + 14, 0, 0, chara_state41);
843 // rinkf1=8;
844 return p;
845 }
846 return p;
847 }
848
849
850 CHARACTER * chara_state33(CHARACTER *p) // right shoulder 783 CHARACTER * chara_state33(CHARACTER *p) // right shoulder
851 { 784 {
852 if (kyeenemyno->f == FALSE) 785 if (kyeenemyno->f == FALSE)
853 { 786 {
854 Bom(p->x, p->y); 787 Bom(p->x, p->y);
1049 } 982 }
1050 } 983 }
1051 p->dt1++; 984 p->dt1++;
1052 return p; 985 return p;
1053 } 986 }
987 #endif
1054 988
1055 989
1056 CHARACTER * chara_state400(CHARACTER *p) 990 CHARACTER * chara_state400(CHARACTER *p)
1057 { 991 {
992 p->task = STATE400;
1058 return SimpleStateTask(p); 993 return SimpleStateTask(p);
1059 } 994 }
1060 995
1061 996
1062 CHARACTER * chara_state401(CHARACTER *p) 997 CHARACTER*
1063 { 998 chara_state401(CHARACTER *p)
1064 p->vx++; 999 {
1065 p->x += p->vx / 8; 1000 p->task = STATE401;
1066 if (p->x > (jiki.x - 32)) 1001 return JikiContainerTask(p);
1067 { 1002 }
1068 p->vy--; 1003
1069 } 1004
1070 p->y += p->vy / 8; 1005 CHARACTER*
1071 if (p->dt1 % 50 == 37) 1006 chara_state402(CHARACTER *p)
1072 { 1007 {
1073 Puttama(1, p->x + 8, p->y + 24); 1008 p->task = STATE402;
1074 } 1009 return JikiContainerTask(p);
1075 p->dt1++; 1010 }
1076 return p; 1011
1077 } 1012
1078 1013 #if 0
1079
1080 CHARACTER * chara_state402(CHARACTER *p)
1081 {
1082 p->vx--;
1083 p->x += p->vx / 8;
1084 if (p->x < (jiki.x + 32))
1085 {
1086 p->vy--;
1087 }
1088 p->y += p->vy / 8;
1089 if (p->dt1 % 50 == 37)
1090 {
1091 Puttama(1, p->x + 8, p->y + 24);
1092 }
1093 p->dt1++;
1094 return p;
1095 }
1096
1097
1098 CHARACTER * chara_state410(CHARACTER *p) 1014 CHARACTER * chara_state410(CHARACTER *p)
1099 { 1015 {
1100 kyeenemyno = p; 1016 kyeenemyno = p;
1101 p->state = chara_state411; 1017 p->state = chara_state411;
1102 return p; 1018 return p;
1263 p->dt2 = 0; 1179 p->dt2 = 0;
1264 } 1180 }
1265 return p; 1181 return p;
1266 } 1182 }
1267 1183
1268
1269 CHARACTER * asteroid(CHARACTER *p)
1270 {
1271 int i;
1272
1273 asteroiddt[asteroidi] = p;
1274 // if(asteroidi==0)
1275 // {
1276 p->x += p->vx;
1277 p->y += p->vy;
1278 // }
1279 if (asteroidi > 0) {
1280 for (i = 0; i < asteroidi; i++) {
1281 if ((asteroiddt[i]->x + 32 > p->x)
1282 && (p->x + 32 > asteroiddt[i]->x)
1283 && (asteroiddt[i]->y + 32 > p->y)
1284 && (asteroiddt[i]->y < p->y + 32)) {
1285 p->vx *= -1;
1286 p->vy *= -1;
1287 }
1288 }
1289 }
1290 asteroidi++;
1291 return p;
1292 }
1293 #endif 1184 #endif