Mercurial > hg > Members > koba > t_dandy

comparison state_task.cc @ 19:00c3272a801f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
fix.
author koba <koba@cr.ie.u-ryukyu.ac.jp>
date Sun, 26 Dec 2010 18:57:08 +0900
parents c330ded6d728
children 5f1abbe03b9a
comparison
equal deleted inserted replaced
18:c330ded6d728 19:00c3272a801f
8 #include "tokuten.h" 8 #include "tokuten.h"
9 #include "collision.h" 9 #include "collision.h"
10 #include "bom.h" 10 #include "bom.h"
11 #include "count2.h" 11 #include "count2.h"
12 #include "sgoex.h" 12 #include "sgoex.h"
13 #include "sankaku.h"
14 #include "tama.h"
13 #include "TaskManager.h" 15 #include "TaskManager.h"
14 #include "Func.h" 16 #include "Func.h"
15 #include "property.h" 17 #include "property.h"
16 #include "state_task.h" 18 #include "state_task.h"
17 19
20 extern SpriteTable sptable[DEFOBJ];
21 extern TaskManager *tmanager;
22
23 CHARACTER *kyeenemyno;
24 CHARACTER *tekino0;
25 CHARACTER *enemy_part1;
26 CHARACTER *enemy_part2;
27 CHARACTER *enemy_part3;
28 CHARACTER *enemy_part4;
29 CHARACTER *enemy_part5;
30
31 //int tekino0;
32 int rinkx;
33 int rinky;
34 int rinkf1 = 0, rinkf2 = 0;
35 CHARACTER *asteroiddt[200];
36 int asteroidi = 0;
37 int enemyfaste = 0;
38 int fastebos = 0;
39
40 State state_list[LIST_NUM];
41
42 int
43 GetStateNum(int task_num)
44 {
45 int num = task_num % LIST_NUM;
46
47 return num;
48 }
49
18 void 50 void
51 SetTaskState(int task_num, CHARACTER *(state)(CHARACTER *chara))
52 {
53 int num = GetStateNum(task_num);
54
55 state_list[num] = state;
56 }
57
58 void
59 initStateList()
60 {
61 SetTaskState(DELETE_CHARA, delete_chara);
62 SetTaskState(STATE0, chara_state0);
63 SetTaskState(STATE1, chara_state1);
64 SetTaskState(STATE2, chara_state2);
65 // SetTaskState(STATE3, chara_state3);
66 SetTaskState(STATE4, chara_state4);
67 SetTaskState(STATE5, chara_state5);
68 SetTaskState(STATE6, chara_state6);
69 #if 0
70 SetTaskState(STATE7, chara_state7);
71 SetTaskState(STATE8, chara_state8);
72 SetTaskState(STATE9, chara_state9);
73 SetTaskState(STATE10, chara_state10);
74 SetTaskState(STATE11, chara_state11);
75 SetTaskState(STATE12, chara_state12);
76 SetTaskState(STATE13, chara_state13);
77 SetTaskState(STATE20, chara_state20);
78 SetTaskState(STATE21, chara_state21);
79 SetTaskState(STATE22, chara_state22);
80 SetTaskState(STATE23, chara_state23);
81 SetTaskState(STATE24, chara_state24);
82 SetTaskState(STATE25, chara_state25);
83 SetTaskState(STATE26, chara_state26);
84 SetTaskState(STATE27, chara_state27);
85 SetTaskState(STATE28, chara_state28);
86 SetTaskState(STATE29, chara_state29);
87 SetTaskState(STATE30, chara_state30);
88 SetTaskState(STATE31, chara_state31);
89 SetTaskState(STATE32, chara_state32);
90 SetTaskState(STATE33, chara_state33);
91 SetTaskState(STATE34, chara_state34);
92 SetTaskState(STATE35, chara_state35);
93 SetTaskState(STATE40, chara_state40);
94 SetTaskState(STATE41, chara_state41);
95 SetTaskState(STATE400, chara_state400);
96 SetTaskState(STATE401, chara_state401);
97 SetTaskState(STATE402, chara_state402);
98 SetTaskState(STATE410, chara_state410);
99 SetTaskState(STATE411, chara_state411);
100 SetTaskState(STATE500, chara_state500);
101 SetTaskState(STATE501, chara_state501);
102 SetTaskState(STATE600, chara_state600);
103 SetTaskState(STATE601, chara_state601);
104 SetTaskState(STATE602, chara_state602);
105 #endif
106 }
107
108 void
109 updateState(SchedTask *s, void *chara, void *arg)
110 {
111 CHARACTER *p = (CHARACTER*)chara;
112
113 int num = GetStateNum(p->task);
114 p=state_list[num](p);
115 }
116
117 CHARACTER*
19 SimpleStateTask(CHARACTER *p) 118 SimpleStateTask(CHARACTER *p)
20 { 119 {
21 HTaskPtr state_task = tmanager->create_task(SIMPLE_STATE); 120 int task_num = p->task;
121 HTaskPtr state_task = tmanager->create_task(task_num);
22 122
23 state_task->add_inData(p, sizeof(CHARACTER)); 123 state_task->add_inData(p, sizeof(CHARACTER));
24 state_task->add_outData(p, sizeof(CHARACTER)); 124 state_task->add_outData(p, sizeof(CHARACTER));
125 state_task->set_post(updateState, (void*)p, NULL);
25 126
26 state_task->set_cpu(SPE_ANY); 127 state_task->set_cpu(SPE_ANY);
27 state_task->spawn(); 128 state_task->spawn();
129
130 return p;
131 }
132
133 CHARACTER*
134 withJikiTask(CHARACTER *p)
135 {
136 int task_num = p->task;
137 HTaskPtr state_task = tmanager->create_task(task_num);
138
139 state_task->add_inData(p, sizeof(CHARACTER));
140 state_task->add_inData(&jiki, sizeof(player));
141 state_task->add_outData(p, sizeof(CHARACTER));
142 state_task->set_post(updateState, (void*)p, NULL);
143
144 state_task->set_cpu(SPE_ANY);
145 state_task->spawn();
146
147 return p;
148 }
149
150 CHARACTER*
151 noaction(CHARACTER *p)
152 {
153 p->state = noaction;
154 return p;
155 }
156
157 CHARACTER *
158 delete_chara(CHARACTER *p)
159 {
160
161 CHARACTER *parent = p;
162 p->f = FALSE;
163 p->state = noaction;
164 p->collision = noaction;
165 return parent;
28 } 166 }
29 167
30 CHARACTER * chara_state0(CHARACTER *p) 168 CHARACTER * chara_state0(CHARACTER *p)
31 { 169 {
32 p->x += p->vx; 170 return SimpleStateTask(p);
33 p->y += p->vy;
34 p->state = STATE0;
35
36 return 0;
37 } 171 }
38 172
39 CHARACTER * chara_state1(CHARACTER *p) 173 CHARACTER * chara_state1(CHARACTER *p)
40 { 174 {
41 p->x -= p->vx; 175 return SimpleStateTask(p);
42 p->y -= p->vy;
43 p->state = STATE1;
44
45 return 0;
46 } 176 }
47 177
48 CHARACTER * chara_state2(CHARACTER *p) 178 CHARACTER * chara_state2(CHARACTER *p)
49 { 179 {
50 p->vy -= 0.25; 180 return SimpleStateTask(p);
51 p->y += p->vy; 181 }
52 p->state = chara_state2; 182
53 //PutSprite(count, p->x, p->y, p->charano); 183 #if 0
54 return 0;
55 }
56
57 CHARACTER * chara_state3(CHARACTER *p) 184 CHARACTER * chara_state3(CHARACTER *p)
58 { 185 {
59 p->x += p->vx; 186 p->x += p->vx;
60 p->y += p->vy; 187 p->y += p->vy;
61 if((p->dt1 == 60) || 188 if((p->dt1 == 60) ||
65 Puttama(0, p->x, p->y); 192 Puttama(0, p->x, p->y);
66 } 193 }
67 p->dt1++; 194 p->dt1++;
68 p->state = chara_state3; 195 p->state = chara_state3;
69 //PutSprite(count, p->x, p->y, p->charano); 196 //PutSprite(count, p->x, p->y, p->charano);
70 return 0; 197 return p;
71 } 198 }
199 #endif
72 200
73 CHARACTER * chara_state4(CHARACTER *p) 201 CHARACTER * chara_state4(CHARACTER *p)
74 { 202 {
75 p->y += p->vy; 203 return withJikiTask(p);
76 p->x += p->vx;
77 if(p->y < jiki.y && p->y + 16 > jiki.y)
78 {
79 p->vy = -2;
80 p->vx = ((jiki.x > p->x) ? 4 : -4);
81 p->state = chara_state7;
82 }
83 else p->state = chara_state4;
84 //PutSprite(count, p->x, p->y, p->charano);
85 return 0;
86 } 204 }
87 205
88 CHARACTER * chara_state5(CHARACTER *p) 206 CHARACTER * chara_state5(CHARACTER *p)
89 { 207 {
90 p->y += p->vy; 208 return withJikiTask(p);
91 p->x += p->vx;
92 if(p->y + 96 < jiki.y
93 && p->y + 128 > jiki.y)
94 {
95 p->vy = -2;
96 p->vx = ((jiki.x > p->x) ? 4 : -4);
97 p->state = chara_state0;
98 }
99 else p->state = chara_state5;
100 //PutSprite(count, p->x, p->y, p->charano);
101 return 0;
102 } 209 }
103 210
104 CHARACTER * chara_state6(CHARACTER *p) 211 CHARACTER * chara_state6(CHARACTER *p)
105 { 212 {
106 p->y += p->vy; 213 return withJikiTask(p);
107 p->x += p->vx; 214 }
108 if(p->y + 96 < jiki.y 215
109 && p->y + 128 > jiki.y) 216 #if 0
110 {
111 p->vy = 2;
112 p->vx = ((jiki.x > p->x) ? 4 : -4);
113 p->state = chara_state0;
114 }
115 else p->state = chara_state6;
116 //PutSprite(count, p->x, p->y, p->charano);
117 return 0;
118 }
119
120 CHARACTER * chara_state7(CHARACTER *p) 217 CHARACTER * chara_state7(CHARACTER *p)
121 { 218 {
122 p->x += p->vx; 219 p->x += p->vx;
123 p->y += p->vy; 220 p->y += p->vy;
124 if((p->dt1 == 60) || (p->dt1 == 90) 221 if((p->dt1 == 60) || (p->dt1 == 90)
127 Puttama(1, p->x, p->y); 224 Puttama(1, p->x, p->y);
128 } 225 }
129 p->dt1++; 226 p->dt1++;
130 p->state = chara_state7; 227 p->state = chara_state7;
131 //PutSprite(count, p->x, p->y, p->charano); 228 //PutSprite(count, p->x, p->y, p->charano);
132 return 0; 229 return p;
133 } 230 }
134 231
135 // state1 boss patern 232 // state1 boss patern
136 CHARACTER * chara_state8(CHARACTER *p) 233 CHARACTER * chara_state8(CHARACTER *p)
137 { 234 {
144 DefSpriteEx(p->charano, 16*4, 32*4); 241 DefSpriteEx(p->charano, 16*4, 32*4);
145 PutSpriteEx(p->charano, (p->x * 4), (p->y * 4), 0.2, 0.2, 1); 242 PutSpriteEx(p->charano, (p->x * 4), (p->y * 4), 0.2, 0.2, 1);
146 p->dt1 = 512; 243 p->dt1 = 512;
147 p->s = 0.125; 244 p->s = 0.125;
148 p->state = chara_state8; 245 p->state = chara_state8;
149 return 0; 246 return p;
150 } 247 }
151 p->state = chara_state9; 248 p->state = chara_state9;
152 return 0; 249 return p;
153 } 250 }
154 251
155 CHARACTER * chara_state9(CHARACTER *p) 252 CHARACTER * chara_state9(CHARACTER *p)
156 { 253 {
157 if(p->s <= 2) 254 if(p->s <= 2)
160 p->y -= 12; 257 p->y -= 12;
161 count++; 258 count++;
162 DefSpriteEx(54, 16*4, 32*4); 259 DefSpriteEx(54, 16*4, 32*4);
163 PutSpriteEx(54, (p->x * 4), (p->y * 4), p->s, p->s, 1); 260 PutSpriteEx(54, (p->x * 4), (p->y * 4), p->s, p->s, 1);
164 p->state = chara_state9; 261 p->state = chara_state9;
165 return 0; 262 return p;
166 } 263 }
167 count++; 264 count++;
168 DefSpriteEx(54, 16, 32); 265 DefSpriteEx(54, 16, 32);
169 PutSpriteEx(54, p->x, p->y, p->s, p->s, 1); 266 PutSpriteEx(54, p->x, p->y, p->s, p->s, 1);
170 rinkx = p->x; 267 rinkx = p->x;
171 rinky = p->y; 268 rinky = p->y;
172 Putenemy(5, rinkx - 16, rinky - 16, 1, 0, chara_state10); 269 Putenemy(5, rinkx - 16, rinky - 16, 1, 0, chara_state10);
173 Putenemy(5, rinkx - 16, rinky - 16, -1, 0, chara_state10); 270 Putenemy(5, rinkx - 16, rinky - 16, -1, 0, chara_state10);
174 p->state = chara_state11; 271 p->state = chara_state11;
175 p->dt1 = 8192; 272 p->dt1 = 8192;
176 return 0; 273 return p;
177 } 274 }
178 275
179 276
180 CHARACTER * chara_state10(CHARACTER *p) 277 CHARACTER * chara_state10(CHARACTER *p)
181 { 278 {
184 p->x += p->vx; 281 p->x += p->vx;
185 p->y += p->vy; 282 p->y += p->vy;
186 p->dt1++; 283 p->dt1++;
187 p->state = chara_state10; 284 p->state = chara_state10;
188 //PutSprite(count, p->x, p->y, 285 //PutSprite(count, p->x, p->y,
189 return 0; 286 return p;
190 } 287 }
191 rinkf1 = 1; 288 rinkf1 = 1;
192 p->dt1 = rinkx; 289 p->dt1 = rinkx;
193 p->dt2 = rinky; 290 p->dt2 = rinky;
194 p->state = chara_state13; 291 p->state = chara_state13;
195 return 0; 292 return p;
196 } 293 }
197 294
198 295
199 CHARACTER * chara_state11(CHARACTER *p) 296 CHARACTER * chara_state11(CHARACTER *p)
200 { 297 {
202 { 299 {
203 count++; 300 count++;
204 DefSpriteEx(54, 16, 32); 301 DefSpriteEx(54, 16, 32);
205 PutSpriteEx(54, p->x, p->y, p->s, p->s, 1); 302 PutSpriteEx(54, p->x, p->y, p->s, p->s, 1);
206 p->state = chara_state11; 303 p->state = chara_state11;
207 return 0; 304 return p;
208 } 305 }
209 p->dt1 = 0; 306 p->dt1 = 0;
210 p->dt2 = 0; 307 p->dt2 = 0;
211 p->state = chara_state12; 308 p->state = chara_state12;
212 return 0; 309 return p;
213 } 310 }
214 311
215 CHARACTER * chara_state12(CHARACTER *p) 312 CHARACTER * chara_state12(CHARACTER *p)
216 { 313 {
217 if(fastebos > 60*60) 314 if(fastebos > 60*60)
224 rinky += 3; 321 rinky += 3;
225 count++; 322 count++;
226 DefSpriteEx(54, 16, 32); 323 DefSpriteEx(54, 16, 32);
227 PutSpriteEx(54, p->x, p->y, 2, 2, 1); 324 PutSpriteEx(54, p->x, p->y, 2, 2, 1);
228 p->state = chara_state12; 325 p->state = chara_state12;
229 return 0; 326 return p;
230 } 327 }
231 if(p->dt1 <= 60) 328 if(p->dt1 <= 60)
232 { 329 {
233 if(jiki.x + 15 - rinkx < -5) 330 if(jiki.x + 15 - rinkx < -5)
234 { 331 {
331 fastebos++; 428 fastebos++;
332 p->dt1++; 429 p->dt1++;
333 count++; 430 count++;
334 DefSpriteEx(54, 16, 32); 431 DefSpriteEx(54, 16, 32);
335 PutSpriteEx(54, p->x, p->y, 2, 2, 1); 432 PutSpriteEx(54, p->x, p->y, 2, 2, 1);
336 return 0; 433 return p;
337 } 434 }
338 435
339 436
340 CHARACTER * chara_state13(CHARACTER *p) 437 CHARACTER * chara_state13(CHARACTER *p)
341 { 438 {
342 if(tekino0->f == FALSE){ 439 if(tekino0->f == FALSE){
343 Bom(p->x, p->y); 440 Bom(p->x, p->y);
344 p->f = FALSE; 441 p->f = FALSE;
345 p->state = delete_chara; 442 p->state = delete_chara;
346 p->collision = noaction; 443 p->collision = noaction;
347 return 0; 444 return p;
348 } 445 }
349 446
350 p->x += rinkx - p->dt1; 447 p->x += rinkx - p->dt1;
351 p->y += rinky - p->dt2; 448 p->y += rinky - p->dt2;
352 p->dt1 = rinkx; 449 p->dt1 = rinkx;
376 if(p->x < rinkx) 473 if(p->x < rinkx)
377 { 474 {
378 Puttama(5, p->x + 8, p->y + 24); 475 Puttama(5, p->x + 8, p->y + 24);
379 } 476 }
380 } 477 }
381 return 0; 478 return p;
382 } 479 }
383 480 #endif
384 481
385 CHARACTER * chara_state20(CHARACTER *p) 482 CHARACTER * chara_state20(CHARACTER *p)
386 { 483 {
387 p->x += p->vx; 484 return SimpleStateTask(p);
388 p->y += p->vy;
389 p->vy -= 0.5;
390 p->vy += 0.4;
391 return 0;
392 } 485 }
393 486
394 CHARACTER * chara_state21(CHARACTER *p) 487 CHARACTER * chara_state21(CHARACTER *p)
395 { 488 {
396 p->x += p->vx; 489 return SimpleStateTask(p);
397 p->y += p->vy; 490 }
398 p->vx += 0.5; 491
399 p->vy += 0.4; 492 #if 0
400 return 0;
401 }
402
403 //ここまでgetate boss 493 //ここまでgetate boss
404 494
405 495
406 CHARACTER * chara_state22(CHARACTER *p) 496 CHARACTER * chara_state22(CHARACTER *p)
407 { 497 {
408 int sf; 498 return SimpleStateTask(p);
409
410 sf = rand() % 4;
411 if((sf == 0) || (sf == 1))
412 {
413 p->x = -35;
414 p->y = rand() % (120 - 35);
415 p->vx = (rand() % 4 + 1);
416 p->vy = rand() % 3 + 1;
417 p->state = chara_state23;
418 }
419 if((sf == 2))
420 {
421 p->x = rand() % 290;
422 p->y = -30;
423 p->vx = rand() % 3 - 1;
424 p->vy = (rand() % 4 + 1);
425 p->state = chara_state23;
426 }
427 if(sf == 3)
428 {
429 p->x = 320;
430 p->y = rand() % (120 - 35);
431 p->vx = (rand() % 4 + 1) * -1;
432 p->vy = rand() % 3 -1;
433 p->state = chara_state23;
434 }
435 return 0;
436 } 499 }
437 500
438 CHARACTER * chara_state23(CHARACTER *p) 501 CHARACTER * chara_state23(CHARACTER *p)
439 { 502 {
440 p=asteroid(p); 503 p=asteroid(p);
441 return 0; 504 return p;
442 } 505 }
443 506
444 CHARACTER * chara_state24(CHARACTER *p) 507 CHARACTER * chara_state24(CHARACTER *p)
445 { 508 {
446 kyeenemyno = p; 509 kyeenemyno = p;
453 rinkx = 0; 516 rinkx = 0;
454 rinky = 0; 517 rinky = 0;
455 rinkf1 = 0; 518 rinkf1 = 0;
456 rinkf2 = 0; 519 rinkf2 = 0;
457 p->state = chara_state25; 520 p->state = chara_state25;
458 return 0; 521 return p;
459 } 522 }
460 523
461 CHARACTER * chara_state25(CHARACTER *p) 524 CHARACTER * chara_state25(CHARACTER *p)
462 { 525 {
463 int amari; 526 int amari;
483 if((amari == 2) && (enemy_part1->f == TRUE)) 546 if((amari == 2) && (enemy_part1->f == TRUE))
484 { 547 {
485 p->state = chara_state27; 548 p->state = chara_state27;
486 rinkf1 = 5; 549 rinkf1 = 5;
487 rinkx = 0; 550 rinkx = 0;
488 return 0; 551 return p;
489 } 552 }
490 if((enemy_part5->f == TRUE) && (enemy_part1->f != TRUE)) 553 if((enemy_part5->f == TRUE) && (enemy_part1->f != TRUE))
491 { 554 {
492 p->state = chara_state28; 555 p->state = chara_state28;
493 } 556 }
494 p->dt1 += 3; 557 p->dt1 += 3;
495 if(p->dt1 == 720) 558 if(p->dt1 == 720)
496 { 559 {
497 p->dt1 = 0; 560 p->dt1 = 0;
498 } 561 }
499 return 0; 562 return p;
500 } 563 }
501 564
502 CHARACTER * chara_state26(CHARACTER *p) 565 CHARACTER * chara_state26(CHARACTER *p)
503 { 566 {
504 if((p->dt2 > 50) && (p->dt2 < 100)) 567 if((p->dt2 > 50) && (p->dt2 < 100))
518 if(p->dt2 == 401) 581 if(p->dt2 == 401)
519 { 582 {
520 p->dt2 = 0; 583 p->dt2 = 0;
521 rinkf1 = 0; 584 rinkf1 = 0;
522 p->state = chara_state25; 585 p->state = chara_state25;
523 return 0; 586 return p;
524 } 587 }
525 p->dt2++; 588 p->dt2++;
526 return 0; 589 return p;
527 } 590 }
528 591
529 CHARACTER * chara_state27(CHARACTER *p) //rocket punch 592 CHARACTER * chara_state27(CHARACTER *p) //rocket punch
530 { 593 {
531 if((p->dt2 > 50) && (p->dt2 < 60) && (p->x > -24) && (p->y > -24)) 594 if((p->dt2 > 50) && (p->dt2 < 60) && (p->x > -24) && (p->y > -24))
574 { 637 {
575 p->dt2 = 0; 638 p->dt2 = 0;
576 rinkf1 = 0; 639 rinkf1 = 0;
577 rinkx = 0; 640 rinkx = 0;
578 p->state = chara_state25; 641 p->state = chara_state25;
579 return 0; 642 return p;
580 } 643 }
581 p->dt2++; 644 p->dt2++;
582 return 0; 645 return p;
583 } 646 }
584 CHARACTER * chara_state28(CHARACTER *p) 647 CHARACTER * chara_state28(CHARACTER *p)
585 { 648 {
586 if (p->dt1 <= 360) 649 if (p->dt1 <= 360)
587 { 650 {
603 1 ? -1 : 1), 666 1 ? -1 : 1),
604 (rand() % 5 + 0.5) * (rand() % 2 == 667 (rand() % 5 + 0.5) * (rand() % 2 ==
605 1 ? -1 : 1), chara_state29); 668 1 ? -1 : 1), chara_state29);
606 } 669 }
607 p->dt1 += 3; 670 p->dt1 += 3;
608 return 0; 671 return p;
609 } 672 }
610 673
611 674
612 CHARACTER * chara_state29(CHARACTER *p) 675 CHARACTER * chara_state29(CHARACTER *p)
613 { 676 {
616 if(p->dt1 % 18 == 1) 679 if(p->dt1 % 18 == 1)
617 { 680 {
618 Puttama(0, p->x, p->y); 681 Puttama(0, p->x, p->y);
619 } 682 }
620 p->dt1++; 683 p->dt1++;
621 return 0; 684 return p;
622 } 685 }
623 686 #endif
624 687
625 CHARACTER * chara_state30(CHARACTER *p) 688 CHARACTER * chara_state30(CHARACTER *p)
626 { 689 {
627 p->x = p->x - 32; 690 return SimpleStateTask(p);
628 p->y = p->y; 691 }
629 return 0; 692
630 } 693 #if 0
631
632 CHARACTER * chara_state31(CHARACTER *p) //right hand 694 CHARACTER * chara_state31(CHARACTER *p) //right hand
633 { 695 {
634 696
635 if((enemy_part3->f == FALSE) || (kyeenemyno->f == FALSE)) 697 if((enemy_part3->f == FALSE) || (kyeenemyno->f == FALSE))
636 { 698 {
637 Bom(p->x, p->y); 699 Bom(p->x, p->y);
638 p->f = FALSE; 700 p->f = FALSE;
639 p->state = delete_chara; 701 p->state = delete_chara;
640 p->collision = noaction; 702 p->collision = noaction;
641 return 0; 703 return p;
642 } 704 }
643 705
644 if(rinkf1 == 0) 706 if(rinkf1 == 0)
645 { 707 {
646 p->x = kyeenemyno->x + 40; 708 p->x = kyeenemyno->x + 40;
661 { 723 {
662 p->y += 6; 724 p->y += 6;
663 } 725 }
664 else 726 else
665 { 727 {
666 return 0; 728 return p;
667 } 729 }
668 count++; 730 count++;
669 PutSprite(count, p->x - 4, p->y - 20, 90 + p->dt2 % 4); 731 PutSprite(count, p->x - 4, p->y - 20, 90 + p->dt2 % 4);
670 p->dt2++; 732 p->dt2++;
671 } 733 }
672 if(rinkf1 == 7) 734 if(rinkf1 == 7)
673 { 735 {
674 Putenemy(22, p->x + 14, p->y + 14, 0, 0, chara_state40); 736 Putenemy(22, p->x + 14, p->y + 14, 0, 0, chara_state40);
675 return 0; 737 return p;
676 } 738 }
677 if(rinkf1 == 11) 739 if(rinkf1 == 11)
678 { 740 {
679 if(p->y + 20 != p->y) 741 if(p->y + 20 != p->y)
680 { 742 {
681 p->y--; 743 p->y--;
682 } 744 }
683 else 745 else
684 { 746 {
685 return 0; 747 return p;
686 } 748 }
687 count++; 749 count++;
688 PutSprite(count, p->x + 8, p->y + 44, 58 + p->dt2 % 4); 750 PutSprite(count, p->x + 8, p->y + 44, 58 + p->dt2 % 4);
689 p->dt2++; 751 p->dt2++;
690 } 752 }
691 return 0; 753 return p;
692 } 754 }
693 755
694 756
695 CHARACTER * chara_state32(CHARACTER *p) //left hand 757 CHARACTER * chara_state32(CHARACTER *p) //left hand
696 { 758 {
699 { 761 {
700 Bom(p->x, p->y); 762 Bom(p->x, p->y);
701 p->f = FALSE; 763 p->f = FALSE;
702 p->state = delete_chara; 764 p->state = delete_chara;
703 p->collision = noaction; 765 p->collision = noaction;
704 return 0; 766 return p;
705 } 767 }
706 p->x = kyeenemyno->x - 40; 768 p->x = kyeenemyno->x - 40;
707 p->y = kyeenemyno->y + 28; 769 p->y = kyeenemyno->y + 28;
708 if (rinkf1 == 5) 770 if (rinkf1 == 5)
709 { 771 {
718 if (rinkf1 == 7) 780 if (rinkf1 == 7)
719 { 781 {
720 Putenemy(23, p->x + 14, 782 Putenemy(23, p->x + 14,
721 p->y + 14, 0, 0, chara_state41); 783 p->y + 14, 0, 0, chara_state41);
722 // rinkf1=8; 784 // rinkf1=8;
723 return 0; 785 return p;
724 } 786 }
725 return 0; 787 return p;
726 } 788 }
727 789
728 790
729 CHARACTER * chara_state33(CHARACTER *p) // right shoulder 791 CHARACTER * chara_state33(CHARACTER *p) // right shoulder
730 { 792 {
732 { 794 {
733 Bom(p->x, p->y); 795 Bom(p->x, p->y);
734 p->f = FALSE; 796 p->f = FALSE;
735 p->state = delete_chara; 797 p->state = delete_chara;
736 p->collision = noaction; 798 p->collision = noaction;
737 return 0; 799 return p;
738 } 800 }
739 p->x = kyeenemyno->x + 32; 801 p->x = kyeenemyno->x + 32;
740 p->y = kyeenemyno->y; 802 p->y = kyeenemyno->y;
741 if (rinkf1 == 5) 803 if (rinkf1 == 5)
742 { 804 {
746 } 808 }
747 if (rinkf1 == 6) 809 if (rinkf1 == 6)
748 { 810 {
749 p->charano = enemystate[11].charano; 811 p->charano = enemystate[11].charano;
750 } 812 }
751 return 0; 813 return p;
752 } 814 }
753 815
754 816
755 CHARACTER * chara_state34(CHARACTER *p) //left shoulder 817 CHARACTER * chara_state34(CHARACTER *p) //left shoulder
756 { 818 {
758 { 820 {
759 Bom(p->x, p->y); 821 Bom(p->x, p->y);
760 p->f = FALSE; 822 p->f = FALSE;
761 p->state = delete_chara; 823 p->state = delete_chara;
762 p->collision = noaction; 824 p->collision = noaction;
763 return 0; 825 return p;
764 } 826 }
765 p->x = kyeenemyno->x - 32; 827 p->x = kyeenemyno->x - 32;
766 p->y = kyeenemyno->y; 828 p->y = kyeenemyno->y;
767 if (rinkf1 == 5) 829 if (rinkf1 == 5)
768 { 830 {
770 } 832 }
771 if (rinkf1 == 6) 833 if (rinkf1 == 6)
772 { 834 {
773 p->charano = enemystate[12].charano; 835 p->charano = enemystate[12].charano;
774 } 836 }
775 return 0; 837 return p;
776 } 838 }
777 839
778 CHARACTER * chara_state35(CHARACTER *p) // bust 840 CHARACTER * chara_state35(CHARACTER *p) // bust
779 { 841 {
780 if (kyeenemyno->f == FALSE) 842 if (kyeenemyno->f == FALSE)
781 { 843 {
782 Bom(p->x, p->y); 844 Bom(p->x, p->y);
783 p->f = FALSE; 845 p->f = FALSE;
784 p->state = delete_chara; 846 p->state = delete_chara;
785 p->collision = noaction; 847 p->collision = noaction;
786 return 0; 848 return p;
787 } 849 }
788 p->x = kyeenemyno->x; 850 p->x = kyeenemyno->x;
789 p->y = kyeenemyno->y + 32; 851 p->y = kyeenemyno->y + 32;
790 if (rinkf1 == 1) 852 if (rinkf1 == 1)
791 { 853 {
823 } 885 }
824 if (rinkf1 == 4) { 886 if (rinkf1 == 4) {
825 p->charano = enemystate[15].charano; 887 p->charano = enemystate[15].charano;
826 p->dt2 = 0; 888 p->dt2 = 0;
827 } 889 }
828 return 0; 890 return p;
829 } 891 }
830 892
831 893
832 CHARACTER * chara_state40(CHARACTER *p) //arm vulkan 894 CHARACTER * chara_state40(CHARACTER *p) //arm vulkan
833 { 895 {
835 { 897 {
836 Bom(p->x, p->y); 898 Bom(p->x, p->y);
837 p->f = FALSE; 899 p->f = FALSE;
838 p->state = delete_chara; 900 p->state = delete_chara;
839 p->collision = noaction; 901 p->collision = noaction;
840 return 0; 902 return p;
841 } 903 }
842 if ((rinkf1 == 8) && (p->dt1 % 3 == 1)) 904 if ((rinkf1 == 8) && (p->dt1 % 3 == 1))
843 { 905 {
844 if ((p->dt2 < 16)) 906 if ((p->dt2 < 16))
845 { 907 {
847 DefSprite(76, "boss2_rightarm_b", 16, p->dt2, 480, boss); 909 DefSprite(76, "boss2_rightarm_b", 16, p->dt2, 480, boss);
848 } 910 }
849 else 911 else
850 { 912 {
851 // rinkf1=9; 913 // rinkf1=9;
852 return 0; 914 return p;
853 } 915 }
854 } 916 }
855 if (rinkf1 == 9) 917 if (rinkf1 == 9)
856 { 918 {
857 if (p->dt1 % 15 == 1) 919 if (p->dt1 % 15 == 1)
873 p->collision = noaction; 935 p->collision = noaction;
874 // rinkf1=11; 936 // rinkf1=11;
875 } 937 }
876 } 938 }
877 p->dt1++; 939 p->dt1++;
878 return 0; 940 return p;
879 } 941 }
880 942
881 943
882 CHARACTER * chara_state41(CHARACTER *p) //left arm up arm vulkan 944 CHARACTER * chara_state41(CHARACTER *p) //left arm up arm vulkan
883 { 945 {
885 { 947 {
886 Bom(p->x, p->y); 948 Bom(p->x, p->y);
887 p->f = FALSE; 949 p->f = FALSE;
888 p->state = delete_chara; 950 p->state = delete_chara;
889 p->collision = noaction; 951 p->collision = noaction;
890 return 0; 952 return p;
891 } 953 }
892 p->x = kyeenemyno->x - 20 - 7; 954 p->x = kyeenemyno->x - 20 - 7;
893 p->y = kyeenemyno->y + 28 + 15; 955 p->y = kyeenemyno->y + 28 + 15;
894 if ((rinkf1 == 8) && (p->dt1 % 3 == 1)) 956 if ((rinkf1 == 8) && (p->dt1 % 3 == 1))
895 { 957 {
899 DefSprite(77, "boss2_leftarmbattery", p->dt2, 16, 480, boss); /*左腕アップアーム砲 */ 961 DefSprite(77, "boss2_leftarmbattery", p->dt2, 16, 480, boss); /*左腕アップアーム砲 */
900 } 962 }
901 else 963 else
902 { 964 {
903 rinkf1 = 9; 965 rinkf1 = 9;
904 return 0; 966 return p;
905 } 967 }
906 } 968 }
907 if (rinkf1 == 9) 969 if (rinkf1 == 9)
908 { 970 {
909 if (p->dt1 % 15 == 1) 971 if (p->dt1 % 15 == 1)
921 else 983 else
922 { 984 {
923 p->f = FALSE; 985 p->f = FALSE;
924 p->state = delete_chara; 986 p->state = delete_chara;
925 p->collision = noaction; 987 p->collision = noaction;
926 return 0; 988 return p;
927 // rinkf1=11; 989 // rinkf1=11;
928 } 990 }
929 } 991 }
930 p->dt1++; 992 p->dt1++;
931 return 0; 993 return p;
932 } 994 }
933 995
934 996
935 CHARACTER * chara_state400(CHARACTER *p) 997 CHARACTER * chara_state400(CHARACTER *p)
936 { 998 {
937 p->vy++; 999 return SimpleStateTask(p);
938 p->y += p->vy / 4;
939 p->state = chara_state400;
940 return 0;
941 } 1000 }
942 1001
943 1002
944 CHARACTER * chara_state401(CHARACTER *p) 1003 CHARACTER * chara_state401(CHARACTER *p)
945 { 1004 {
953 if (p->dt1 % 50 == 37) 1012 if (p->dt1 % 50 == 37)
954 { 1013 {
955 Puttama(1, p->x + 8, p->y + 24); 1014 Puttama(1, p->x + 8, p->y + 24);
956 } 1015 }
957 p->dt1++; 1016 p->dt1++;
958 return 0; 1017 return p;
959 } 1018 }
960 1019
961 1020
962 CHARACTER * chara_state402(CHARACTER *p) 1021 CHARACTER * chara_state402(CHARACTER *p)
963 { 1022 {
971 if (p->dt1 % 50 == 37) 1030 if (p->dt1 % 50 == 37)
972 { 1031 {
973 Puttama(1, p->x + 8, p->y + 24); 1032 Puttama(1, p->x + 8, p->y + 24);
974 } 1033 }
975 p->dt1++; 1034 p->dt1++;
976 return 0; 1035 return p;
977 } 1036 }
978 1037
979 1038
980 CHARACTER * chara_state410(CHARACTER *p) 1039 CHARACTER * chara_state410(CHARACTER *p)
981 { 1040 {
982 kyeenemyno = p; 1041 kyeenemyno = p;
983 p->state = chara_state411; 1042 p->state = chara_state411;
984 return 0; 1043 return p;
985 } 1044 }
986 1045
987 1046
988 CHARACTER * chara_state411(CHARACTER *p) 1047 CHARACTER * chara_state411(CHARACTER *p)
989 { 1048 {
1028 } 1087 }
1029 if (p->y > 232) 1088 if (p->y > 232)
1030 { 1089 {
1031 p->y = 232; 1090 p->y = 232;
1032 } 1091 }
1033 return 0; 1092 return p;
1034 } 1093 }
1035 1094
1036 1095
1037 CHARACTER * chara_state500(CHARACTER *p) 1096 CHARACTER * chara_state500(CHARACTER *p)
1038 { 1097 {
1064 SANKAKU, chara_state501); 1123 SANKAKU, chara_state501);
1065 } 1124 }
1066 if (p->dt1 == 50) { 1125 if (p->dt1 == 50) {
1067 /*Putenemy(44,0,0,1,1,411); */ 1126 /*Putenemy(44,0,0,1,1,411); */
1068 } 1127 }
1069 return 0; 1128 return p;
1070 } 1129 }
1071 1130
1072 1131
1073 CHARACTER * chara_state501(CHARACTER *p) 1132 CHARACTER * chara_state501(CHARACTER *p)
1074 { 1133 {
1077 if(p->dt1 % 32 == 1) 1136 if(p->dt1 % 32 == 1)
1078 { 1137 {
1079 Puttama(11, p->x, p->y); 1138 Puttama(11, p->x, p->y);
1080 } 1139 }
1081 p->dt1++; 1140 p->dt1++;
1082 return 0; 1141 return p;
1083 } 1142 }
1084 1143
1085 1144
1086 CHARACTER * chara_state600(CHARACTER *p) 1145 CHARACTER * chara_state600(CHARACTER *p)
1087 { 1146 {
1102 p->x = 260; 1161 p->x = 260;
1103 if (p->y < 0) 1162 if (p->y < 0)
1104 p->y = 0; 1163 p->y = 0;
1105 if (p->y > 232) 1164 if (p->y > 232)
1106 p->y = 232; 1165 p->y = 232;
1107 return 0; 1166 return p;
1108 } 1167 }
1109 1168
1110 1169
1111 CHARACTER * chara_state601(CHARACTER *p) 1170 CHARACTER * chara_state601(CHARACTER *p)
1112 { 1171 {
1127 if (p->y > 232) 1186 if (p->y > 232)
1128 p->y = 232; 1187 p->y = 232;
1129 if (p->dt2 > 800) { 1188 if (p->dt2 > 800) {
1130 p->state = chara_state602; 1189 p->state = chara_state602;
1131 } 1190 }
1132 return 0; 1191 return p;
1133 } 1192 }
1134 1193
1135 1194
1136 CHARACTER * chara_state602(CHARACTER *p) 1195 CHARACTER * chara_state602(CHARACTER *p)
1137 { 1196 {
1142 chara_state29); 1201 chara_state29);
1143 if (p->dt2 > 1024) { 1202 if (p->dt2 > 1024) {
1144 p->state = chara_state600; 1203 p->state = chara_state600;
1145 p->dt2 = 0; 1204 p->dt2 = 0;
1146 } 1205 }
1147 return 0; 1206 return p;
1148 } 1207 }
1149 1208
1150 1209
1151 CHARACTER * asteroid(CHARACTER *p) 1210 CHARACTER * asteroid(CHARACTER *p)
1152 { 1211 {
1168 p->vy *= -1; 1227 p->vy *= -1;
1169 } 1228 }
1170 } 1229 }
1171 } 1230 }
1172 asteroidi++; 1231 asteroidi++;
1173 return 0; 1232 return p;
1174 } 1233 }
1234 #endif