Mercurial > hg > Members > tkaito > t_dandy_old

comparison state_task.cc @ 0:4be1ca60a49b default tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
first commit.
author tkaito
date Sat, 05 Feb 2011 02:13:58 +0900
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:4be1ca60a49b
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 "tokuten.h"
9 #include "collision.h"
10 #include "bom.h"
11 #include "count2.h"
12 #include "sgoex.h"
13 #include "sankaku.h"
14 #include "tama.h"
15 #include "TaskManager.h"
16 #include "Func.h"
17 #include "property.h"
18 #include "state_task.h"
19 #include "ObjectType.h"
20
21 extern SpriteTable sptable[DEFOBJ];
22 extern TaskManager *tmanager;
23
24 CHARACTER *kyeenemyno = NULL;
25 CHARACTER *tekino0 = NULL;
26 CHARACTER *enemy_part1 = NULL;
27 CHARACTER *enemy_part2 = NULL;
28 CHARACTER *enemy_part3 = NULL;
29 CHARACTER *enemy_part4 = NULL;
30 CHARACTER *enemy_part5 = NULL;
31
32 //int tekino0;
33 int rinkx = 0;
34 int rinky = 0;
35 int rinkf1 = 0, rinkf2 = 0;
36 CHARACTER *asteroiddt[200];
37 int asteroidi = 0;
38 int enemyfaste = 0;
39 int fastebos = 0;
40
41 int counter = 0;
42
43 State state_list[LIST_NUM];
44
45 /* output 0~3 */
46 static
47 int get_num()
48 {
49 counter++;
50 counter %= 4;
51 return counter;
52 }
53
54 static
55 int power_of_two(int input)
56 {
57 int value = 1;
58
59 while ( value < input ) {
60 value <<= 1;
61 }
62 return value;
63 }
64
65 static void
66 ReDefSprite(int number, float w, float h, int color)
67 {
68 SpriteTable *m = &sptable[number];
69 m->w = w;
70 m->h = h;
71 m->color = (color & 32);
72 m->mx = w / 2;
73 m->my = h / 2;
74 m->tex_w = power_of_two(m->w);
75 m->tex_h = power_of_two(m->h);
76 }
77
78
79 static int
80 GetStateNum(int task_num)
81 {
82 int num = task_num % LIST_NUM;
83
84 return num;
85 }
86
87 static void
88 SetTaskState(int task_num, CHARACTER *(state)(CHARACTER *chara))
89 {
90 int num = GetStateNum(task_num);
91
92 state_list[num] = state;
93 }
94
95 void
96 initStateList()
97 {
98 SetTaskState(DELETE_CHARA, delete_chara);
99 SetTaskState(STATE0, chara_state0);
100 SetTaskState(STATE1, chara_state1);
101 SetTaskState(STATE2, chara_state2);
102 SetTaskState(STATE3, chara_state3);
103 SetTaskState(STATE4, chara_state4);
104 SetTaskState(STATE5, chara_state5);
105 SetTaskState(STATE6, chara_state6);
106 SetTaskState(STATE7, chara_state7);
107 SetTaskState(STATE8, chara_state8);
108 SetTaskState(STATE9, chara_state9);
109 SetTaskState(STATE10, chara_state10);
110 SetTaskState(STATE11, chara_state11);
111 SetTaskState(STATE12, chara_state12);
112 SetTaskState(STATE13, chara_state13);
113
114 SetTaskState(STATE20, chara_state20);
115 SetTaskState(STATE21, chara_state21);
116 SetTaskState(STATE22, chara_state22);
117 SetTaskState(STATE23, chara_state23);
118 SetTaskState(STATE24, chara_state24);
119 SetTaskState(STATE25, chara_state25);
120 SetTaskState(STATE26, chara_state26);
121 SetTaskState(STATE27, chara_state27);
122 SetTaskState(STATE28, chara_state28);
123 SetTaskState(STATE29, chara_state29);
124 SetTaskState(STATE30, chara_state30);
125 SetTaskState(STATE31, chara_state31);
126 SetTaskState(STATE32, chara_state32);
127 SetTaskState(STATE33, chara_state33);
128 SetTaskState(STATE34, chara_state34);
129 SetTaskState(STATE35, chara_state35);
130 SetTaskState(STATE40, chara_state40);
131 SetTaskState(STATE41, chara_state41);
132
133 SetTaskState(STATE400, chara_state400);
134 SetTaskState(STATE401, chara_state401);
135 SetTaskState(STATE402, chara_state402);
136
137 SetTaskState(STATE410, chara_state410);
138 SetTaskState(STATE411, chara_state411);
139
140 SetTaskState(STATE500, chara_state500);
141 SetTaskState(STATE501, chara_state501);
142
143 SetTaskState(STATE600, chara_state600);
144 SetTaskState(STATE601, chara_state601);
145 SetTaskState(STATE602, chara_state602);
146 }
147
148 void
149 updateState(SchedTask *s, void *chara, void *arg)
150 {
151 CHARACTER *p = (CHARACTER*)chara;
152
153 int num = GetStateNum(p->task);
154 p->state = state_list[num];
155 }
156
157
158 void
159 PrintCoordinate(SchedTask *s, void *chara, void *arg)
160 {
161 CHARACTER *p = (CHARACTER*)chara;
162 printf("x = %f, y = %f, vx = %f, vy = %f\n",p->x, p->y, p->vx, p->vy);
163
164 int num = GetStateNum(p->task);
165 p->state = state_list[num];
166 }
167
168
169 void
170 freeObject(SchedTask *s, void *chara, void *obj)
171 {
172 free(obj);
173
174 CHARACTER *p = (CHARACTER*)chara;
175
176 int num = GetStateNum(p->task);
177 p->state = state_list[num];
178 }
179
180
181 void
182 checkContainer(SchedTask *s, void *chara, void *obj)
183 {
184 CHARACTER *p = (CHARACTER*)chara;
185 ObjContainer *new_obj = (ObjContainerPtr)obj;
186
187 if (new_obj->flag == true) {
188 int length = new_obj->length;
189
190 for (int i=0; i < length; i++) {
191 ObjDataPtr obj_data = &new_obj->data[i];
192 int type = obj_data->type;
193
194 switch (type) {
195 case Boms:
196 Bom(obj_data->x, obj_data->y);
197 break;
198 case Tama:
199 Puttama(obj_data->tama_type, obj_data->x, obj_data->y);
200 break;
201 case Enemy: {
202 int task_num = GetStateNum(obj_data->task);
203 Putenemy(obj_data->charano, obj_data->x, obj_data->y,
204 obj_data->vx, obj_data->vy, state_list[task_num]);
205 break;
206 }
207 case Def:
208 ReDefSprite(obj_data->number, obj_data->w, obj_data->h, obj_data->color);
209 break;
210 case DefEx:
211 DefSpriteEx(obj_data->number, obj_data->middlex, obj_data->middley);
212 break;
213 case Put:
214 PutSprite(obj_data->zorder, obj_data->x, obj_data->y, obj_data->number);
215 break;
216 case PutEx:
217 PutSpriteEx(obj_data->number, obj_data->x, obj_data->y,
218 obj_data->scalex, obj_data->scaley, obj_data->angle);
219 break;
220 }
221 }
222 }
223 int num = GetStateNum(p->task);
224 p->state = state_list[num];
225
226 free(new_obj);
227 }
228
229
230 CHARACTER*
231 SimpleStateTask(CHARACTER *p)
232 {
233 int task_num = p->task;
234 HTaskPtr state_task = tmanager->create_task(task_num);
235
236 state_task->set_inData(0, p, sizeof(CHARACTER));
237
238 state_task->set_outData(0, p, sizeof(CHARACTER));
239
240 state_task->set_post(updateState, (void*)p, NULL);
241 state_task->set_cpu(SPE_ANY);
242 state_task->spawn();
243
244 return p;
245 }
246
247
248 CHARACTER*
249 FixRandomTask(CHARACTER *p)
250 {
251 int task_num = p->task;
252 HTaskPtr state_task = tmanager->create_task(task_num);
253
254 state_task->set_param(0, (memaddr)get_num());
255
256 state_task->set_inData(0, p, sizeof(CHARACTER));
257
258 state_task->set_outData(0, p, sizeof(CHARACTER));
259
260 state_task->set_post(PrintCoordinate, (void*)p, NULL);
261 state_task->set_cpu(SPE_ANY);
262 state_task->spawn();
263
264 return p;
265 }
266
267
268 CHARACTER*
269 withJikiTask(CHARACTER *p)
270 {
271 int task_num = p->task;
272 HTaskPtr state_task = tmanager->create_task(task_num);
273
274 state_task->set_inData(0, p, sizeof(CHARACTER));
275 state_task->set_inData(1, &jiki, sizeof(player));
276
277 state_task->set_outData(0, p, sizeof(CHARACTER));
278
279 state_task->set_post(updateState, (void*)p, NULL);
280 state_task->set_cpu(SPE_ANY);
281 state_task->spawn();
282
283 return p;
284 }
285
286
287 CHARACTER*
288 sendContainerTask(CHARACTER *p)
289 {
290 int task_num = p->task;
291 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
292 HTaskPtr state_task = tmanager->create_task(task_num);
293 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
294 obj->flag = false;
295 obj->length = 0;
296
297 state_task->set_inData(0, p, sizeof(CHARACTER));
298
299 state_task->set_outData(0, p, sizeof(CHARACTER));
300 state_task->set_outData(1, obj, 0);
301
302 state_task->set_post(checkContainer, (void*)p, (void*)obj);
303 state_task->set_cpu(SPE_ANY);
304 state_task->spawn();
305
306 return p;
307 }
308
309
310 CHARACTER*
311 JikiContainerTask(CHARACTER *p)
312 {
313 int task_num = p->task;
314 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
315 HTaskPtr state_task = tmanager->create_task(task_num);
316 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
317 obj->flag = false;
318 obj->length = 0;
319
320 state_task->set_inData(0, p, sizeof(CHARACTER));
321 state_task->set_inData(1, &jiki, sizeof(player));
322
323 state_task->set_outData(0, p, sizeof(CHARACTER));
324 state_task->set_outData(1, obj, 0);
325
326 state_task->set_post(checkContainer, (void*)p, (void*)obj);
327 state_task->set_cpu(SPE_ANY);
328 state_task->spawn();
329
330 return p;
331 }
332
333
334 CHARACTER*
335 AsteroidTask(CHARACTER *p)
336 {
337 asteroiddt[asteroidi] = p;
338
339 int task_num = ASTEROID_TASK;
340 HTaskPtr state_task = tmanager->create_task(task_num);
341
342 state_task->set_param(0, (memaddr)asteroidi);
343
344 state_task->set_inData(0, p, sizeof(CHARACTER));
345
346 state_task->set_outData(0, p, sizeof(CHARACTER));
347
348 int array_size = sizeof(CHARACTER)*asteroidi;
349 if (array_size > 0) {
350 CHARACTER *asteroid_array = (CHARACTER*)tmanager->allocate(array_size);
351 for (int i = 0; i < asteroidi; i++) {
352 asteroid_array[i] = *asteroiddt[i];
353 }
354 state_task->set_inData(1, asteroid_array, array_size);
355 state_task->set_post(freeObject, (void*)p, (void*)asteroid_array);
356 } else {
357 state_task->set_post(updateState, (void*)p, NULL);
358 }
359 state_task->set_cpu(SPE_ANY);
360 state_task->spawn();
361
362 asteroidi++;
363 return p;
364 }
365
366
367 CHARACTER*
368 Boss1Task1(CHARACTER *p)
369 {
370 int task_num = p->task;
371 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
372 HTaskPtr state_task = tmanager->create_task(task_num);
373 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
374 obj->flag = false;
375 obj->length = 0;
376
377 state_task->set_inData(0, p, sizeof(CHARACTER));
378 state_task->set_inData(1, &count, sizeof(int));
379
380 state_task->set_outData(0, p, sizeof(CHARACTER));
381 state_task->set_outData(1, &count, sizeof(int));
382 state_task->set_outData(2, obj, 0);
383
384 state_task->set_post(checkContainer, (void*)p, (void*)obj);
385 state_task->set_cpu(SPE_ANY);
386 state_task->spawn();
387
388 return p;
389 }
390
391
392 CHARACTER*
393 Boss1Task2(CHARACTER *p)
394 {
395 int task_num = p->task;
396 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
397 HTaskPtr state_task = tmanager->create_task(task_num);
398 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
399 obj->flag = false;
400 obj->length = 0;
401
402 state_task->set_inData(0, p, sizeof(CHARACTER));
403 state_task->set_inData(1, &count, sizeof(int));
404
405 state_task->set_outData(0, p, sizeof(CHARACTER));
406 state_task->set_outData(1, &count, sizeof(int));
407 state_task->set_outData(2, &rinkx, sizeof(int));
408 state_task->set_outData(3, &rinky, sizeof(int));
409 state_task->set_outData(4, obj, 0);
410
411 state_task->set_post(checkContainer, (void*)p, (void*)obj);
412 state_task->set_cpu(SPE_ANY);
413 state_task->spawn();
414
415 return p;
416 }
417
418
419 CHARACTER*
420 Boss1Task3(CHARACTER *p)
421 {
422 int task_num = p->task;
423 HTaskPtr state_task = tmanager->create_task(task_num);
424
425 state_task->set_param(0, (memaddr)rinkx);
426 state_task->set_param(1, (memaddr)rinky);
427
428 state_task->set_inData(0, p, sizeof(CHARACTER));
429
430 state_task->set_outData(0, p, sizeof(CHARACTER));
431 state_task->set_outData(1, &rinkf1, sizeof(int));
432
433 state_task->set_post(updateState, (void*)p, NULL);
434 state_task->set_cpu(SPE_ANY);
435 state_task->spawn();
436
437 return p;
438 }
439
440
441 CHARACTER*
442 Boss1Task4(CHARACTER *p)
443 {
444 int task_num = p->task;
445 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
446 HTaskPtr state_task = tmanager->create_task(task_num);
447 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
448 obj->flag = false;
449 obj->length = 0;
450
451 state_task->set_param(0, (memaddr)rinkf1);
452 state_task->set_param(1, (memaddr)count);
453
454 state_task->set_inData(0, p, sizeof(CHARACTER));
455
456 state_task->set_outData(0, p, sizeof(CHARACTER));
457 state_task->set_outData(1, &count, sizeof(int));
458 state_task->set_outData(2, obj, 0);
459
460 state_task->set_post(checkContainer, (void*)p, (void*)obj);
461 state_task->set_cpu(SPE_ANY);
462 state_task->spawn();
463
464 return p;
465 }
466
467
468 CHARACTER*
469 Boss1Task5(CHARACTER *p)
470 {
471 int task_num = p->task;
472 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
473 HTaskPtr state_task = tmanager->create_task(task_num);
474 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
475 obj->flag = false;
476 obj->length = 0;
477
478 state_task->set_param(0, (memaddr)fastebos);
479 state_task->set_param(1, (memaddr)count);
480 state_task->set_param(2, (memaddr)rinkx);
481 state_task->set_param(3, (memaddr)rinky);
482
483 state_task->set_inData(0, p, sizeof(CHARACTER));
484 state_task->set_inData(1, &jiki, sizeof(player));
485
486 state_task->set_outData(0, p, sizeof(CHARACTER));
487 state_task->set_outData(1, &count, sizeof(int));
488 state_task->set_outData(2, &fastebos, sizeof(int));
489 state_task->set_outData(3, &rinkx, sizeof(int));
490 state_task->set_outData(4, &rinky, sizeof(int));
491 state_task->set_outData(5, &rinkf2, sizeof(int));
492 state_task->set_outData(6, obj, 0);
493
494 state_task->set_post(checkContainer, (void*)p, (void*)obj);
495 state_task->set_cpu(SPE_ANY);
496 state_task->spawn();
497
498 return p;
499 }
500
501
502 CHARACTER*
503 Boss1Task6(CHARACTER *p)
504 {
505 int task_num = p->task;
506 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
507 HTaskPtr state_task = tmanager->create_task(task_num);
508 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
509 obj->flag = false;
510 obj->length = 0;
511
512 state_task->set_param(0, (memaddr)rinkx);
513 state_task->set_param(1, (memaddr)rinky);
514 state_task->set_param(2, (memaddr)filpcount);
515 state_task->set_param(3, (memaddr)tekino0->f);
516 state_task->set_param(4, (memaddr)count);
517
518 state_task->set_inData(0, p, sizeof(CHARACTER));
519 state_task->set_inData(1, &rinkf2, sizeof(int));
520
521 state_task->set_outData(0, p, sizeof(CHARACTER));
522 state_task->set_outData(1, &count, sizeof(int));
523 state_task->set_outData(2, obj, 0);
524
525 state_task->set_post(checkContainer, (void*)p, (void*)obj);
526 state_task->set_cpu(SPE_ANY);
527 state_task->spawn();
528
529 return p;
530 }
531
532
533 CHARACTER*
534 Boss2Task1(CHARACTER *p)
535 {
536 int task_num = p->task;
537 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
538 HTaskPtr state_task = tmanager->create_task(task_num);
539 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
540 obj->flag = false;
541 obj->length = 0;
542
543 state_task->set_param(0, (memaddr)enemy_part1->f);
544 state_task->set_param(1, (memaddr)enemy_part5->f);
545 state_task->set_param(2, (memaddr)get_num());
546
547 state_task->set_inData(0, p, sizeof(CHARACTER));
548 state_task->set_inData(1, &count, sizeof(int));
549 state_task->set_inData(2, &rinkx, sizeof(int));
550 state_task->set_inData(3, &rinkf1, sizeof(int));
551
552 state_task->set_outData(0, p, sizeof(CHARACTER));
553 state_task->set_outData(1, &count, sizeof(int));
554 state_task->set_outData(2, &rinkx, sizeof(int));
555 state_task->set_outData(3, &rinkf1, sizeof(int));
556 state_task->set_outData(4, obj, 0);
557
558 state_task->set_post(checkContainer, (void*)p, (void*)obj);
559 state_task->set_cpu(SPE_ANY);
560 state_task->spawn();
561
562 return p;
563 }
564
565
566 CHARACTER*
567 Boss2Task2(CHARACTER *p, int num1, int num2)
568 {
569 int task_num = p->task;
570 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
571 HTaskPtr state_task = tmanager->create_task(task_num);
572 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
573 obj->flag = false;
574 obj->length = 0;
575
576 state_task->set_param(0, (memaddr)enemy_part1->f);
577 state_task->set_param(1, (memaddr)enemy_part2->f);
578 state_task->set_param(2, (memaddr)enemy_part3->f);
579 state_task->set_param(3, (memaddr)enemy_part4->f);
580 state_task->set_param(4, (memaddr)enemystate[num1].charano);
581 state_task->set_param(5, (memaddr)enemystate[num2].charano);
582 state_task->set_param(6, (memaddr)get_num());
583
584 state_task->set_inData(0, p, sizeof(CHARACTER));
585 state_task->set_inData(1, kyeenemyno, sizeof(CHARACTER));
586 state_task->set_inData(2, &count, sizeof(int));
587 state_task->set_inData(3, &rinkf1, sizeof(int));
588
589 state_task->set_outData(0, p, sizeof(CHARACTER));
590 state_task->set_outData(1, &count, sizeof(int));
591 state_task->set_outData(2, obj, 0);
592
593 state_task->set_post(checkContainer, (void*)p, (void*)obj);
594 state_task->set_cpu(SPE_ANY);
595 state_task->spawn();
596
597 return p;
598 }
599
600
601 CHARACTER*
602 Boss4Task(CHARACTER *p)
603 {
604 kyeenemyno = p;
605
606 int task_num = p->task;
607 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
608 HTaskPtr state_task = tmanager->create_task(task_num);
609 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
610 obj->flag = false;
611 obj->length = 0;
612
613 state_task->set_param(0, (memaddr)get_num());
614
615 state_task->set_inData(0, p, sizeof(CHARACTER));
616 state_task->set_inData(1, &count, sizeof(int));
617
618 state_task->set_outData(0, p, sizeof(CHARACTER));
619 state_task->set_outData(1, &count, sizeof(int));
620 state_task->set_outData(2, obj, 0);
621
622 state_task->set_post(checkContainer, (void*)p, (void*)obj);
623 state_task->set_cpu(SPE_ANY);
624 state_task->spawn();
625
626 return p;
627 }
628
629
630 CHARACTER*
631 Boss5Task(CHARACTER *p)
632 {
633 int task_num = p->task;
634 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
635 HTaskPtr state_task = tmanager->create_task(task_num);
636 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
637 obj->flag = false;
638 obj->length = 0;
639
640 state_task->set_param(0, (memaddr)get_num());
641
642 state_task->set_inData(0, p, sizeof(CHARACTER));
643 state_task->set_inData(1, &jiki, sizeof(player));
644
645 state_task->set_outData(0, p, sizeof(CHARACTER));
646 state_task->set_outData(1, obj, 0);
647
648 state_task->set_post(checkContainer, (void*)p, (void*)obj);
649 state_task->set_cpu(SPE_ANY);
650 state_task->spawn();
651
652 return p;
653 }
654
655
656 CHARACTER*
657 noaction(CHARACTER *p)
658 {
659 return p;
660 }
661
662
663 CHARACTER*
664 delete_chara(CHARACTER *p)
665 {
666 CHARACTER *parent = p;
667 printf("x = %f, y = %f, vx = %f, vy = %f\n",p->x, p->y, p->vx, p->vy);
668 p->f = FALSE;
669 p->state = noaction;
670 p->collision = noaction;
671 return parent;
672 }
673
674
675 CHARACTER*
676 chara_state0(CHARACTER *p)
677 {
678 p->task = STATE0;
679 return SimpleStateTask(p);
680 }
681
682
683 CHARACTER*
684 chara_state1(CHARACTER *p)
685 {
686 p->task = STATE1;
687 return SimpleStateTask(p);
688 }
689
690
691 CHARACTER*
692 chara_state2(CHARACTER *p)
693 {
694 p->task = STATE2;
695 return SimpleStateTask(p);
696 }
697
698
699 CHARACTER*
700 chara_state3(CHARACTER *p)
701 {
702 p->task = STATE3;
703 return sendContainerTask(p);
704 }
705
706
707 CHARACTER*
708 chara_state4(CHARACTER *p)
709 {
710 p->task = STATE4;
711 return withJikiTask(p);
712 }
713
714
715 CHARACTER*
716 chara_state5(CHARACTER *p)
717 {
718 p->task = STATE5;
719 return withJikiTask(p);
720 }
721
722
723 CHARACTER*
724 chara_state6(CHARACTER *p)
725 {
726 p->task = STATE6;
727 return withJikiTask(p);
728 }
729
730
731 CHARACTER*
732 chara_state7(CHARACTER *p)
733 {
734 p->task = STATE7;
735 return sendContainerTask(p);
736 }
737
738
739 // state1 boss patern
740 CHARACTER*
741 chara_state8(CHARACTER *p)
742 {
743 tekino0 = p;
744 kyeenemyno = p;
745
746 p->task = STATE8;
747 return Boss1Task1(p);
748 }
749
750
751 CHARACTER*
752 chara_state9(CHARACTER *p)
753 {
754 p->task = STATE9;
755 return Boss1Task2(p);
756 }
757
758
759 CHARACTER*
760 chara_state10(CHARACTER *p)
761 {
762 p->task =STATE10;
763 return Boss1Task3(p);
764 }
765
766
767 CHARACTER*
768 chara_state11(CHARACTER *p)
769 {
770 p->task = STATE11;
771 return Boss1Task4(p);
772 }
773
774
775 CHARACTER*
776 chara_state12(CHARACTER *p)
777 {
778 p->task = STATE12;
779 return Boss1Task5(p);
780 }
781
782
783 CHARACTER*
784 chara_state13(CHARACTER *p)
785 {
786 p->task = STATE13;
787 return Boss1Task6(p);
788 }
789
790
791 CHARACTER*
792 chara_state20(CHARACTER *p)
793 {
794 p->task = STATE20;
795 return SimpleStateTask(p);
796 }
797
798
799 CHARACTER*
800 chara_state21(CHARACTER *p)
801 {
802 p->task = STATE21;
803 return SimpleStateTask(p);
804 }
805 //ここまでgetate boss
806
807
808 CHARACTER*
809 chara_state22(CHARACTER *p)
810 {
811 p->task = STATE22;
812 return FixRandomTask(p);
813 }
814
815
816 CHARACTER*
817 chara_state23(CHARACTER *p)
818 {
819 p->task = STATE23;
820 return AsteroidTask(p);
821 }
822
823
824 CHARACTER*
825 chara_state24(CHARACTER *p)
826 {
827 kyeenemyno = p;
828 tekino0 = 0;
829 enemy_part1 = p->next;
830 enemy_part2 = enemy_part1->next;
831 enemy_part3 = enemy_part2->next;
832 enemy_part4 = enemy_part3->next;
833 enemy_part5 = enemy_part4->next;
834 rinkx = 0;
835 rinky = 0;
836 rinkf1 = 0;
837 rinkf2 = 0;
838 p->task = STATE25;
839
840 int num = GetStateNum(p->task);
841 p->state = state_list[num];
842 return p;
843 }
844
845 CHARACTER*
846 chara_state25(CHARACTER *p)
847 {
848 p->task = STATE25;
849 return Boss2Task1(p);
850 }
851
852 CHARACTER*
853 chara_state26(CHARACTER *p)
854 {
855 p->task = STATE26;
856 return Boss2Task1(p);
857 }
858
859 CHARACTER*
860 chara_state27(CHARACTER *p) //rocket punch
861 {
862 p->task = STATE27;
863 return Boss2Task1(p);
864 }
865 CHARACTER*
866 chara_state28(CHARACTER *p)
867 {
868 p->task = STATE28;
869 return Boss2Task1(p);
870 }
871
872
873 CHARACTER*
874 chara_state29(CHARACTER *p)
875 {
876 p->task = STATE29;
877 return sendContainerTask(p);
878 }
879
880
881 CHARACTER*
882 chara_state30(CHARACTER *p)
883 {
884 p->task = STATE30;
885 return SimpleStateTask(p);
886 }
887
888
889 CHARACTER*
890 chara_state31(CHARACTER *p) //right hand
891 {
892 p->task = STATE31;
893 return Boss2Task2(p, 0, 0);
894 }
895
896
897 CHARACTER*
898 chara_state32(CHARACTER *p) //left hand
899 {
900 p->task = STATE32;
901 return Boss2Task2(p, 14, 20);
902 }
903
904
905
906 CHARACTER*
907 chara_state33(CHARACTER *p) // right shoulder
908 {
909 p->task = STATE33;
910 return Boss2Task2(p, 11, 19);
911 }
912
913
914 CHARACTER*
915 chara_state34(CHARACTER *p) //left shoulder
916 {
917 p->task = STATE34;
918 return Boss2Task2(p, 12, 21);
919 }
920
921
922 CHARACTER*
923 chara_state35(CHARACTER *p) // bust
924 {
925 p->task = STATE35;
926 return Boss2Task2(p, 15, 16);
927 }
928
929
930
931 CHARACTER*
932 chara_state40(CHARACTER *p) //arm vulkan
933 {
934 p->task = STATE40;
935 return Boss2Task2(p, 0, 0);
936 }
937
938
939 CHARACTER*
940 chara_state41(CHARACTER *p) //left arm up arm vulkan
941 {
942 p->task = STATE41;
943 return Boss2Task2(p, 0, 0);
944 }
945
946
947 CHARACTER*
948 chara_state400(CHARACTER *p)
949 {
950 p->task = STATE400;
951 return SimpleStateTask(p);
952 }
953
954
955 CHARACTER*
956 chara_state401(CHARACTER *p)
957 {
958 p->task = STATE401;
959 return JikiContainerTask(p);
960 }
961
962
963 CHARACTER*
964 chara_state402(CHARACTER *p)
965 {
966 p->task = STATE402;
967 return JikiContainerTask(p);
968 }
969
970
971 CHARACTER*
972 chara_state410(CHARACTER *p)
973 {
974 kyeenemyno = p;
975 p->task = STATE411;
976
977 int num = GetStateNum(p->task);
978 p->state = state_list[num];
979 return p;
980 }
981
982
983 CHARACTER*
984 chara_state411(CHARACTER *p)
985 {
986 p->task = STATE411;
987 return JikiContainerTask(p);
988 }
989
990
991 CHARACTER*
992 chara_state500(CHARACTER *p)
993 {
994 p->task = STATE500;
995 return Boss4Task(p);
996 }
997
998
999 CHARACTER*
1000 chara_state501(CHARACTER *p)
1001 {
1002 p->task = STATE501;
1003 return sendContainerTask(p);
1004 }
1005
1006
1007 CHARACTER*
1008 chara_state600(CHARACTER *p)
1009 {
1010 kyeenemyno = p;
1011 p->task = STATE600;
1012 return sendContainerTask(p);
1013 }
1014
1015
1016 CHARACTER*
1017 chara_state601(CHARACTER *p)
1018 {
1019 p->task = STATE601;
1020 return Boss5Task(p);
1021 }
1022
1023
1024 CHARACTER*
1025 chara_state602(CHARACTER *p)
1026 {
1027 p->task = STATE602;
1028 return Boss5Task(p);
1029 }